1 // Copyright 2015-2021 The Khronos Group Inc. 2 // 3 // SPDX-License-Identifier: Apache-2.0 OR MIT 4 // 5 6 // This header is generated from the Khronos Vulkan XML API Registry. 7 8 #ifndef VULKAN_RAII_HPP 9 #define VULKAN_RAII_HPP 10 11 #include <vulkan/vulkan.hpp> 12 13 #if !defined( VULKAN_HPP_RAII_NAMESPACE ) 14 # define VULKAN_HPP_RAII_NAMESPACE raii 15 #endif 16 17 namespace VULKAN_HPP_NAMESPACE 18 { 19 namespace VULKAN_HPP_RAII_NAMESPACE 20 { 21 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) && !defined( VULKAN_HPP_NO_EXCEPTIONS ) 22 23 template <class T, class U = T> exchange(T & obj,U && newValue)24 VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange( T & obj, U && newValue ) 25 { 26 # if ( 14 <= VULKAN_HPP_CPP_VERSION ) 27 return std::exchange<T>( obj, std::forward<U>( newValue ) ); 28 # else 29 T oldValue = std::move( obj ); 30 obj = std::forward<U>( newValue ); 31 return oldValue; 32 # endif 33 } 34 35 class ContextDispatcher : public DispatchLoaderBase 36 { 37 public: ContextDispatcher(PFN_vkGetInstanceProcAddr getProcAddr)38 ContextDispatcher( PFN_vkGetInstanceProcAddr getProcAddr ) 39 : vkGetInstanceProcAddr( getProcAddr ) 40 //=== VK_VERSION_1_0 === 41 , vkCreateInstance( PFN_vkCreateInstance( getProcAddr( NULL, "vkCreateInstance" ) ) ) 42 , vkEnumerateInstanceExtensionProperties( PFN_vkEnumerateInstanceExtensionProperties( 43 getProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) ) ) 44 , vkEnumerateInstanceLayerProperties( 45 PFN_vkEnumerateInstanceLayerProperties( getProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) ) ) 46 //=== VK_VERSION_1_1 === 47 , vkEnumerateInstanceVersion( 48 PFN_vkEnumerateInstanceVersion( getProcAddr( NULL, "vkEnumerateInstanceVersion" ) ) ) 49 {} 50 51 public: 52 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; 53 54 //=== VK_VERSION_1_0 === 55 PFN_vkCreateInstance vkCreateInstance = 0; 56 PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; 57 PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; 58 59 //=== VK_VERSION_1_1 === 60 PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; 61 }; 62 63 class InstanceDispatcher : public DispatchLoaderBase 64 { 65 public: InstanceDispatcher(PFN_vkGetInstanceProcAddr getProcAddr,VkInstance instance)66 InstanceDispatcher( PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance ) 67 : vkGetInstanceProcAddr( getProcAddr ) 68 { 69 //=== VK_VERSION_1_0 === 70 vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) ); 71 vkEnumeratePhysicalDevices = 72 PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) ); 73 vkGetPhysicalDeviceFeatures = 74 PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) ); 75 vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties( 76 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) ); 77 vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties( 78 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) ); 79 vkGetPhysicalDeviceProperties = 80 PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) ); 81 vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties( 82 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) ); 83 vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties( 84 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) ); 85 vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) ); 86 vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties( 87 vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) ); 88 vkEnumerateDeviceLayerProperties = 89 PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) ); 90 vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties( 91 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); 92 93 //=== VK_VERSION_1_1 === 94 vkEnumeratePhysicalDeviceGroups = 95 PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) ); 96 vkGetPhysicalDeviceFeatures2 = 97 PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) ); 98 vkGetPhysicalDeviceProperties2 = 99 PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) ); 100 vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2( 101 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) ); 102 vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2( 103 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) ); 104 vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2( 105 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); 106 vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2( 107 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) ); 108 vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( 109 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) ); 110 vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties( 111 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) ); 112 vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties( 113 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) ); 114 vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( 115 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) ); 116 117 //=== VK_EXT_acquire_drm_display === 118 vkAcquireDrmDisplayEXT = 119 PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) ); 120 vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) ); 121 122 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 123 //=== VK_EXT_acquire_xlib_display === 124 vkAcquireXlibDisplayEXT = 125 PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); 126 vkGetRandROutputDisplayEXT = 127 PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); 128 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 129 130 //=== VK_EXT_calibrated_timestamps === 131 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( 132 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) ); 133 134 //=== VK_EXT_debug_report === 135 vkCreateDebugReportCallbackEXT = 136 PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) ); 137 vkDestroyDebugReportCallbackEXT = 138 PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) ); 139 vkDebugReportMessageEXT = 140 PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) ); 141 142 //=== VK_EXT_debug_utils === 143 vkCreateDebugUtilsMessengerEXT = 144 PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) ); 145 vkDestroyDebugUtilsMessengerEXT = 146 PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) ); 147 vkSubmitDebugUtilsMessageEXT = 148 PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) ); 149 150 //=== VK_EXT_direct_mode_display === 151 vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); 152 153 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 154 //=== VK_EXT_directfb_surface === 155 vkCreateDirectFBSurfaceEXT = 156 PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) ); 157 vkGetPhysicalDeviceDirectFBPresentationSupportEXT = PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( 158 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) ); 159 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 160 161 //=== VK_EXT_display_surface_counter === 162 vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( 163 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) ); 164 165 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 166 //=== VK_EXT_full_screen_exclusive === 167 vkGetPhysicalDeviceSurfacePresentModes2EXT = PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( 168 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) ); 169 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 170 171 //=== VK_EXT_headless_surface === 172 vkCreateHeadlessSurfaceEXT = 173 PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) ); 174 175 # if defined( VK_USE_PLATFORM_METAL_EXT ) 176 //=== VK_EXT_metal_surface === 177 vkCreateMetalSurfaceEXT = 178 PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); 179 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 180 181 //=== VK_EXT_sample_locations === 182 vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( 183 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) ); 184 185 //=== VK_EXT_tooling_info === 186 vkGetPhysicalDeviceToolPropertiesEXT = PFN_vkGetPhysicalDeviceToolPropertiesEXT( 187 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) ); 188 189 # if defined( VK_USE_PLATFORM_FUCHSIA ) 190 //=== VK_FUCHSIA_imagepipe_surface === 191 vkCreateImagePipeSurfaceFUCHSIA = 192 PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) ); 193 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 194 195 # if defined( VK_USE_PLATFORM_GGP ) 196 //=== VK_GGP_stream_descriptor_surface === 197 vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( 198 vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); 199 # endif /*VK_USE_PLATFORM_GGP*/ 200 201 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 202 //=== VK_KHR_android_surface === 203 vkCreateAndroidSurfaceKHR = 204 PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) ); 205 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 206 207 //=== VK_KHR_device_group === 208 vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR( 209 vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) ); 210 211 //=== VK_KHR_device_group_creation === 212 vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( 213 vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) ); 214 if ( !vkEnumeratePhysicalDeviceGroups ) 215 vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR; 216 217 //=== VK_KHR_display === 218 vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( 219 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) ); 220 vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 221 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) ); 222 vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR( 223 vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) ); 224 vkGetDisplayModePropertiesKHR = 225 PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) ); 226 vkCreateDisplayModeKHR = 227 PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) ); 228 vkGetDisplayPlaneCapabilitiesKHR = 229 PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) ); 230 vkCreateDisplayPlaneSurfaceKHR = 231 PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) ); 232 233 //=== VK_KHR_external_fence_capabilities === 234 vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( 235 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) ); 236 if ( !vkGetPhysicalDeviceExternalFenceProperties ) 237 vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR; 238 239 //=== VK_KHR_external_memory_capabilities === 240 vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( 241 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) ); 242 if ( !vkGetPhysicalDeviceExternalBufferProperties ) 243 vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR; 244 245 //=== VK_KHR_external_semaphore_capabilities === 246 vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 247 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) ); 248 if ( !vkGetPhysicalDeviceExternalSemaphoreProperties ) 249 vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; 250 251 //=== VK_KHR_fragment_shading_rate === 252 vkGetPhysicalDeviceFragmentShadingRatesKHR = PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( 253 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) ); 254 255 //=== VK_KHR_get_display_properties2 === 256 vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR( 257 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) ); 258 vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( 259 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) ); 260 vkGetDisplayModeProperties2KHR = 261 PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) ); 262 vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( 263 vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) ); 264 265 //=== VK_KHR_get_physical_device_properties2 === 266 vkGetPhysicalDeviceFeatures2KHR = 267 PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) ); 268 if ( !vkGetPhysicalDeviceFeatures2 ) 269 vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR; 270 vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( 271 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) ); 272 if ( !vkGetPhysicalDeviceProperties2 ) 273 vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR; 274 vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR( 275 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) ); 276 if ( !vkGetPhysicalDeviceFormatProperties2 ) 277 vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR; 278 vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( 279 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) ); 280 if ( !vkGetPhysicalDeviceImageFormatProperties2 ) 281 vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR; 282 vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( 283 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) ); 284 if ( !vkGetPhysicalDeviceQueueFamilyProperties2 ) 285 vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; 286 vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR( 287 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) ); 288 if ( !vkGetPhysicalDeviceMemoryProperties2 ) 289 vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR; 290 vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( 291 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) ); 292 if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 ) 293 vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR; 294 295 //=== VK_KHR_get_surface_capabilities2 === 296 vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( 297 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) ); 298 vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( 299 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); 300 301 //=== VK_KHR_performance_query === 302 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 303 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 304 vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) ); 305 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 306 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( 307 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) ); 308 309 //=== VK_KHR_surface === 310 vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) ); 311 vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR( 312 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); 313 vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 314 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); 315 vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( 316 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); 317 vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( 318 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); 319 320 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 321 //=== VK_KHR_video_queue === 322 vkGetPhysicalDeviceVideoCapabilitiesKHR = PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( 323 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) ); 324 vkGetPhysicalDeviceVideoFormatPropertiesKHR = PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( 325 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) ); 326 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 327 328 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 329 //=== VK_KHR_wayland_surface === 330 vkCreateWaylandSurfaceKHR = 331 PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) ); 332 vkGetPhysicalDeviceWaylandPresentationSupportKHR = PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( 333 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) ); 334 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 335 336 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 337 //=== VK_KHR_win32_surface === 338 vkCreateWin32SurfaceKHR = 339 PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) ); 340 vkGetPhysicalDeviceWin32PresentationSupportKHR = PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( 341 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) ); 342 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 343 344 # if defined( VK_USE_PLATFORM_XCB_KHR ) 345 //=== VK_KHR_xcb_surface === 346 vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) ); 347 vkGetPhysicalDeviceXcbPresentationSupportKHR = PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( 348 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) ); 349 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 350 351 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 352 //=== VK_KHR_xlib_surface === 353 vkCreateXlibSurfaceKHR = 354 PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) ); 355 vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( 356 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) ); 357 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 358 359 # if defined( VK_USE_PLATFORM_IOS_MVK ) 360 //=== VK_MVK_ios_surface === 361 vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) ); 362 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 363 364 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 365 //=== VK_MVK_macos_surface === 366 vkCreateMacOSSurfaceMVK = 367 PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) ); 368 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 369 370 # if defined( VK_USE_PLATFORM_VI_NN ) 371 //=== VK_NN_vi_surface === 372 vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); 373 # endif /*VK_USE_PLATFORM_VI_NN*/ 374 375 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 376 //=== VK_NV_acquire_winrt_display === 377 vkAcquireWinrtDisplayNV = 378 PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); 379 vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) ); 380 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 381 382 //=== VK_NV_cooperative_matrix === 383 vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( 384 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) ); 385 386 //=== VK_NV_coverage_reduction_mode === 387 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 388 PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 389 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) ); 390 391 //=== VK_NV_external_memory_capabilities === 392 vkGetPhysicalDeviceExternalImageFormatPropertiesNV = PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 393 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) ); 394 395 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 396 //=== VK_QNX_screen_surface === 397 vkCreateScreenSurfaceQNX = 398 PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) ); 399 vkGetPhysicalDeviceScreenPresentationSupportQNX = PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( 400 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) ); 401 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 402 403 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) ); 404 } 405 406 public: 407 //=== VK_VERSION_1_0 === 408 PFN_vkDestroyInstance vkDestroyInstance = 0; 409 PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; 410 PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; 411 PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; 412 PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; 413 PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; 414 PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; 415 PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; 416 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; 417 PFN_vkCreateDevice vkCreateDevice = 0; 418 PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; 419 PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; 420 PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; 421 422 //=== VK_VERSION_1_1 === 423 PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; 424 PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; 425 PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; 426 PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; 427 PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; 428 PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; 429 PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; 430 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; 431 PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; 432 PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; 433 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; 434 435 //=== VK_EXT_acquire_drm_display === 436 PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; 437 PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; 438 439 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 440 //=== VK_EXT_acquire_xlib_display === 441 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; 442 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; 443 # else 444 PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; 445 PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; 446 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 447 448 //=== VK_EXT_calibrated_timestamps === 449 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; 450 451 //=== VK_EXT_debug_report === 452 PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; 453 PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; 454 PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; 455 456 //=== VK_EXT_debug_utils === 457 PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; 458 PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; 459 PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; 460 461 //=== VK_EXT_direct_mode_display === 462 PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; 463 464 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 465 //=== VK_EXT_directfb_surface === 466 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; 467 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; 468 # else 469 PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; 470 PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; 471 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 472 473 //=== VK_EXT_display_surface_counter === 474 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; 475 476 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 477 //=== VK_EXT_full_screen_exclusive === 478 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; 479 # else 480 PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; 481 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 482 483 //=== VK_EXT_headless_surface === 484 PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; 485 486 # if defined( VK_USE_PLATFORM_METAL_EXT ) 487 //=== VK_EXT_metal_surface === 488 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; 489 # else 490 PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; 491 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 492 493 //=== VK_EXT_sample_locations === 494 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; 495 496 //=== VK_EXT_tooling_info === 497 PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0; 498 499 # if defined( VK_USE_PLATFORM_FUCHSIA ) 500 //=== VK_FUCHSIA_imagepipe_surface === 501 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; 502 # else 503 PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; 504 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 505 506 # if defined( VK_USE_PLATFORM_GGP ) 507 //=== VK_GGP_stream_descriptor_surface === 508 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; 509 # else 510 PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; 511 # endif /*VK_USE_PLATFORM_GGP*/ 512 513 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 514 //=== VK_KHR_android_surface === 515 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; 516 # else 517 PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; 518 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 519 520 //=== VK_KHR_device_group === 521 PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; 522 523 //=== VK_KHR_device_group_creation === 524 PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; 525 526 //=== VK_KHR_display === 527 PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; 528 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; 529 PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; 530 PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; 531 PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; 532 PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; 533 PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; 534 535 //=== VK_KHR_external_fence_capabilities === 536 PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; 537 538 //=== VK_KHR_external_memory_capabilities === 539 PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; 540 541 //=== VK_KHR_external_semaphore_capabilities === 542 PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; 543 544 //=== VK_KHR_fragment_shading_rate === 545 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0; 546 547 //=== VK_KHR_get_display_properties2 === 548 PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; 549 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; 550 PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; 551 PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; 552 553 //=== VK_KHR_get_physical_device_properties2 === 554 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; 555 PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; 556 PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; 557 PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; 558 PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; 559 PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; 560 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; 561 562 //=== VK_KHR_get_surface_capabilities2 === 563 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; 564 PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; 565 566 //=== VK_KHR_performance_query === 567 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR 568 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; 569 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR 570 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; 571 572 //=== VK_KHR_surface === 573 PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; 574 PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; 575 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; 576 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; 577 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; 578 579 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 580 //=== VK_KHR_video_queue === 581 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0; 582 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0; 583 # else 584 PFN_dummy vkGetPhysicalDeviceVideoCapabilitiesKHR_placeholder = 0; 585 PFN_dummy vkGetPhysicalDeviceVideoFormatPropertiesKHR_placeholder = 0; 586 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 587 588 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 589 //=== VK_KHR_wayland_surface === 590 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; 591 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; 592 # else 593 PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; 594 PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; 595 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 596 597 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 598 //=== VK_KHR_win32_surface === 599 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; 600 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; 601 # else 602 PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; 603 PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; 604 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 605 606 # if defined( VK_USE_PLATFORM_XCB_KHR ) 607 //=== VK_KHR_xcb_surface === 608 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; 609 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; 610 # else 611 PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; 612 PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; 613 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 614 615 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 616 //=== VK_KHR_xlib_surface === 617 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; 618 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; 619 # else 620 PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; 621 PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; 622 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 623 624 # if defined( VK_USE_PLATFORM_IOS_MVK ) 625 //=== VK_MVK_ios_surface === 626 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; 627 # else 628 PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; 629 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 630 631 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 632 //=== VK_MVK_macos_surface === 633 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; 634 # else 635 PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; 636 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 637 638 # if defined( VK_USE_PLATFORM_VI_NN ) 639 //=== VK_NN_vi_surface === 640 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; 641 # else 642 PFN_dummy vkCreateViSurfaceNN_placeholder = 0; 643 # endif /*VK_USE_PLATFORM_VI_NN*/ 644 645 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 646 //=== VK_NV_acquire_winrt_display === 647 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; 648 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; 649 # else 650 PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; 651 PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; 652 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 653 654 //=== VK_NV_cooperative_matrix === 655 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0; 656 657 //=== VK_NV_coverage_reduction_mode === 658 PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV 659 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; 660 661 //=== VK_NV_external_memory_capabilities === 662 PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; 663 664 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 665 //=== VK_QNX_screen_surface === 666 PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; 667 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; 668 # else 669 PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; 670 PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; 671 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 672 673 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; 674 }; 675 676 class DeviceDispatcher : public DispatchLoaderBase 677 { 678 public: DeviceDispatcher(PFN_vkGetDeviceProcAddr getProcAddr,VkDevice device)679 DeviceDispatcher( PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device ) : vkGetDeviceProcAddr( getProcAddr ) 680 { 681 //=== VK_VERSION_1_0 === 682 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) ); 683 vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) ); 684 vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) ); 685 vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) ); 686 vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) ); 687 vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) ); 688 vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) ); 689 vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) ); 690 vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) ); 691 vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) ); 692 vkFlushMappedMemoryRanges = 693 PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) ); 694 vkInvalidateMappedMemoryRanges = 695 PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) ); 696 vkGetDeviceMemoryCommitment = 697 PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) ); 698 vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) ); 699 vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) ); 700 vkGetBufferMemoryRequirements = 701 PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) ); 702 vkGetImageMemoryRequirements = 703 PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) ); 704 vkGetImageSparseMemoryRequirements = 705 PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) ); 706 vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) ); 707 vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) ); 708 vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) ); 709 vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) ); 710 vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) ); 711 vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) ); 712 vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) ); 713 vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) ); 714 vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) ); 715 vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) ); 716 vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) ); 717 vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) ); 718 vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) ); 719 vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) ); 720 vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) ); 721 vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) ); 722 vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) ); 723 vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) ); 724 vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) ); 725 vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) ); 726 vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) ); 727 vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) ); 728 vkGetImageSubresourceLayout = 729 PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) ); 730 vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) ); 731 vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) ); 732 vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) ); 733 vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) ); 734 vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) ); 735 vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) ); 736 vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) ); 737 vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) ); 738 vkCreateGraphicsPipelines = 739 PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) ); 740 vkCreateComputePipelines = 741 PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) ); 742 vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) ); 743 vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) ); 744 vkDestroyPipelineLayout = 745 PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) ); 746 vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) ); 747 vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) ); 748 vkCreateDescriptorSetLayout = 749 PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) ); 750 vkDestroyDescriptorSetLayout = 751 PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) ); 752 vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) ); 753 vkDestroyDescriptorPool = 754 PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) ); 755 vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) ); 756 vkAllocateDescriptorSets = 757 PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) ); 758 vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) ); 759 vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) ); 760 vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) ); 761 vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) ); 762 vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) ); 763 vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) ); 764 vkGetRenderAreaGranularity = 765 PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) ); 766 vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) ); 767 vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) ); 768 vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) ); 769 vkAllocateCommandBuffers = 770 PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) ); 771 vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) ); 772 vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) ); 773 vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) ); 774 vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) ); 775 vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) ); 776 vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) ); 777 vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) ); 778 vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) ); 779 vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) ); 780 vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) ); 781 vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) ); 782 vkCmdSetStencilCompareMask = 783 PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) ); 784 vkCmdSetStencilWriteMask = 785 PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) ); 786 vkCmdSetStencilReference = 787 PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) ); 788 vkCmdBindDescriptorSets = 789 PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) ); 790 vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) ); 791 vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) ); 792 vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) ); 793 vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) ); 794 vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) ); 795 vkCmdDrawIndexedIndirect = 796 PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) ); 797 vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) ); 798 vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) ); 799 vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) ); 800 vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) ); 801 vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) ); 802 vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) ); 803 vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) ); 804 vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) ); 805 vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) ); 806 vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) ); 807 vkCmdClearDepthStencilImage = 808 PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) ); 809 vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) ); 810 vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) ); 811 vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) ); 812 vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) ); 813 vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) ); 814 vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) ); 815 vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) ); 816 vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) ); 817 vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) ); 818 vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) ); 819 vkCmdCopyQueryPoolResults = 820 PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) ); 821 vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) ); 822 vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) ); 823 vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) ); 824 vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) ); 825 vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) ); 826 827 //=== VK_VERSION_1_1 === 828 vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) ); 829 vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) ); 830 vkGetDeviceGroupPeerMemoryFeatures = 831 PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) ); 832 vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) ); 833 vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) ); 834 vkGetImageMemoryRequirements2 = 835 PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) ); 836 vkGetBufferMemoryRequirements2 = 837 PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) ); 838 vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( 839 vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) ); 840 vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) ); 841 vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) ); 842 vkCreateSamplerYcbcrConversion = 843 PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) ); 844 vkDestroySamplerYcbcrConversion = 845 PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) ); 846 vkCreateDescriptorUpdateTemplate = 847 PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) ); 848 vkDestroyDescriptorUpdateTemplate = 849 PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) ); 850 vkUpdateDescriptorSetWithTemplate = 851 PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) ); 852 vkGetDescriptorSetLayoutSupport = 853 PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) ); 854 855 //=== VK_VERSION_1_2 === 856 vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) ); 857 vkCmdDrawIndexedIndirectCount = 858 PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) ); 859 vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) ); 860 vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) ); 861 vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) ); 862 vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) ); 863 vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) ); 864 vkGetSemaphoreCounterValue = 865 PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) ); 866 vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) ); 867 vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) ); 868 vkGetBufferDeviceAddress = 869 PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) ); 870 vkGetBufferOpaqueCaptureAddress = 871 PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) ); 872 vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress( 873 vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); 874 875 //=== VK_AMD_buffer_marker === 876 vkCmdWriteBufferMarkerAMD = 877 PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) ); 878 879 //=== VK_AMD_display_native_hdr === 880 vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) ); 881 882 //=== VK_AMD_draw_indirect_count === 883 vkCmdDrawIndirectCountAMD = 884 PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) ); 885 if ( !vkCmdDrawIndirectCount ) 886 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; 887 vkCmdDrawIndexedIndirectCountAMD = 888 PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) ); 889 if ( !vkCmdDrawIndexedIndirectCount ) 890 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; 891 892 //=== VK_AMD_shader_info === 893 vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) ); 894 895 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 896 //=== VK_ANDROID_external_memory_android_hardware_buffer === 897 vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID( 898 vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); 899 vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( 900 vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); 901 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 902 903 //=== VK_EXT_buffer_device_address === 904 vkGetBufferDeviceAddressEXT = 905 PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) ); 906 if ( !vkGetBufferDeviceAddress ) 907 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; 908 909 //=== VK_EXT_calibrated_timestamps === 910 vkGetCalibratedTimestampsEXT = 911 PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) ); 912 913 //=== VK_EXT_color_write_enable === 914 vkCmdSetColorWriteEnableEXT = 915 PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) ); 916 917 //=== VK_EXT_conditional_rendering === 918 vkCmdBeginConditionalRenderingEXT = 919 PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) ); 920 vkCmdEndConditionalRenderingEXT = 921 PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) ); 922 923 //=== VK_EXT_debug_marker === 924 vkDebugMarkerSetObjectTagEXT = 925 PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) ); 926 vkDebugMarkerSetObjectNameEXT = 927 PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) ); 928 vkCmdDebugMarkerBeginEXT = 929 PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) ); 930 vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) ); 931 vkCmdDebugMarkerInsertEXT = 932 PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) ); 933 934 //=== VK_EXT_debug_utils === 935 vkSetDebugUtilsObjectNameEXT = 936 PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) ); 937 vkSetDebugUtilsObjectTagEXT = 938 PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) ); 939 vkQueueBeginDebugUtilsLabelEXT = 940 PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) ); 941 vkQueueEndDebugUtilsLabelEXT = 942 PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) ); 943 vkQueueInsertDebugUtilsLabelEXT = 944 PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) ); 945 vkCmdBeginDebugUtilsLabelEXT = 946 PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) ); 947 vkCmdEndDebugUtilsLabelEXT = 948 PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) ); 949 vkCmdInsertDebugUtilsLabelEXT = 950 PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) ); 951 952 //=== VK_EXT_discard_rectangles === 953 vkCmdSetDiscardRectangleEXT = 954 PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) ); 955 956 //=== VK_EXT_display_control === 957 vkDisplayPowerControlEXT = 958 PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) ); 959 vkRegisterDeviceEventEXT = 960 PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) ); 961 vkRegisterDisplayEventEXT = 962 PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) ); 963 vkGetSwapchainCounterEXT = 964 PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) ); 965 966 //=== VK_EXT_extended_dynamic_state === 967 vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) ); 968 vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) ); 969 vkCmdSetPrimitiveTopologyEXT = 970 PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) ); 971 vkCmdSetViewportWithCountEXT = 972 PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) ); 973 vkCmdSetScissorWithCountEXT = 974 PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) ); 975 vkCmdBindVertexBuffers2EXT = 976 PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) ); 977 vkCmdSetDepthTestEnableEXT = 978 PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) ); 979 vkCmdSetDepthWriteEnableEXT = 980 PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) ); 981 vkCmdSetDepthCompareOpEXT = 982 PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) ); 983 vkCmdSetDepthBoundsTestEnableEXT = 984 PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) ); 985 vkCmdSetStencilTestEnableEXT = 986 PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) ); 987 vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) ); 988 989 //=== VK_EXT_extended_dynamic_state2 === 990 vkCmdSetPatchControlPointsEXT = 991 PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) ); 992 vkCmdSetRasterizerDiscardEnableEXT = 993 PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) ); 994 vkCmdSetDepthBiasEnableEXT = 995 PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) ); 996 vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) ); 997 vkCmdSetPrimitiveRestartEnableEXT = 998 PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) ); 999 1000 //=== VK_EXT_external_memory_host === 1001 vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( 1002 vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) ); 1003 1004 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 1005 //=== VK_EXT_full_screen_exclusive === 1006 vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( 1007 vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) ); 1008 vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( 1009 vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) ); 1010 vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( 1011 vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); 1012 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 1013 1014 //=== VK_EXT_hdr_metadata === 1015 vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) ); 1016 1017 //=== VK_EXT_host_query_reset === 1018 vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) ); 1019 if ( !vkResetQueryPool ) 1020 vkResetQueryPool = vkResetQueryPoolEXT; 1021 1022 //=== VK_EXT_image_drm_format_modifier === 1023 vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( 1024 vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); 1025 1026 //=== VK_EXT_line_rasterization === 1027 vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) ); 1028 1029 //=== VK_EXT_multi_draw === 1030 vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) ); 1031 vkCmdDrawMultiIndexedEXT = 1032 PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) ); 1033 1034 //=== VK_EXT_pageable_device_local_memory === 1035 vkSetDeviceMemoryPriorityEXT = 1036 PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) ); 1037 1038 //=== VK_EXT_private_data === 1039 vkCreatePrivateDataSlotEXT = 1040 PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) ); 1041 vkDestroyPrivateDataSlotEXT = 1042 PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) ); 1043 vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) ); 1044 vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) ); 1045 1046 //=== VK_EXT_sample_locations === 1047 vkCmdSetSampleLocationsEXT = 1048 PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) ); 1049 1050 //=== VK_EXT_transform_feedback === 1051 vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( 1052 vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) ); 1053 vkCmdBeginTransformFeedbackEXT = 1054 PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) ); 1055 vkCmdEndTransformFeedbackEXT = 1056 PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) ); 1057 vkCmdBeginQueryIndexedEXT = 1058 PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) ); 1059 vkCmdEndQueryIndexedEXT = 1060 PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) ); 1061 vkCmdDrawIndirectByteCountEXT = 1062 PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) ); 1063 1064 //=== VK_EXT_validation_cache === 1065 vkCreateValidationCacheEXT = 1066 PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) ); 1067 vkDestroyValidationCacheEXT = 1068 PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) ); 1069 vkMergeValidationCachesEXT = 1070 PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) ); 1071 vkGetValidationCacheDataEXT = 1072 PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) ); 1073 1074 //=== VK_EXT_vertex_input_dynamic_state === 1075 vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) ); 1076 1077 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1078 //=== VK_FUCHSIA_buffer_collection === 1079 vkCreateBufferCollectionFUCHSIA = 1080 PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) ); 1081 vkSetBufferCollectionImageConstraintsFUCHSIA = PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( 1082 vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); 1083 vkSetBufferCollectionBufferConstraintsFUCHSIA = PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( 1084 vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); 1085 vkDestroyBufferCollectionFUCHSIA = 1086 PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) ); 1087 vkGetBufferCollectionPropertiesFUCHSIA = PFN_vkGetBufferCollectionPropertiesFUCHSIA( 1088 vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); 1089 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1090 1091 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1092 //=== VK_FUCHSIA_external_memory === 1093 vkGetMemoryZirconHandleFUCHSIA = 1094 PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) ); 1095 vkGetMemoryZirconHandlePropertiesFUCHSIA = PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( 1096 vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); 1097 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1098 1099 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1100 //=== VK_FUCHSIA_external_semaphore === 1101 vkImportSemaphoreZirconHandleFUCHSIA = PFN_vkImportSemaphoreZirconHandleFUCHSIA( 1102 vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); 1103 vkGetSemaphoreZirconHandleFUCHSIA = 1104 PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); 1105 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1106 1107 //=== VK_GOOGLE_display_timing === 1108 vkGetRefreshCycleDurationGOOGLE = 1109 PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) ); 1110 vkGetPastPresentationTimingGOOGLE = 1111 PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) ); 1112 1113 //=== VK_HUAWEI_invocation_mask === 1114 vkCmdBindInvocationMaskHUAWEI = 1115 PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) ); 1116 1117 //=== VK_HUAWEI_subpass_shading === 1118 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( 1119 vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); 1120 vkCmdSubpassShadingHUAWEI = 1121 PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) ); 1122 1123 //=== VK_INTEL_performance_query === 1124 vkInitializePerformanceApiINTEL = 1125 PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) ); 1126 vkUninitializePerformanceApiINTEL = 1127 PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) ); 1128 vkCmdSetPerformanceMarkerINTEL = 1129 PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) ); 1130 vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( 1131 vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); 1132 vkCmdSetPerformanceOverrideINTEL = 1133 PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) ); 1134 vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( 1135 vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) ); 1136 vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( 1137 vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) ); 1138 vkQueueSetPerformanceConfigurationINTEL = PFN_vkQueueSetPerformanceConfigurationINTEL( 1139 vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) ); 1140 vkGetPerformanceParameterINTEL = 1141 PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) ); 1142 1143 //=== VK_KHR_acceleration_structure === 1144 vkCreateAccelerationStructureKHR = 1145 PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) ); 1146 vkDestroyAccelerationStructureKHR = 1147 PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) ); 1148 vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( 1149 vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) ); 1150 vkCmdBuildAccelerationStructuresIndirectKHR = PFN_vkCmdBuildAccelerationStructuresIndirectKHR( 1151 vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); 1152 vkBuildAccelerationStructuresKHR = 1153 PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) ); 1154 vkCopyAccelerationStructureKHR = 1155 PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) ); 1156 vkCopyAccelerationStructureToMemoryKHR = PFN_vkCopyAccelerationStructureToMemoryKHR( 1157 vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) ); 1158 vkCopyMemoryToAccelerationStructureKHR = PFN_vkCopyMemoryToAccelerationStructureKHR( 1159 vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) ); 1160 vkWriteAccelerationStructuresPropertiesKHR = PFN_vkWriteAccelerationStructuresPropertiesKHR( 1161 vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) ); 1162 vkCmdCopyAccelerationStructureKHR = 1163 PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) ); 1164 vkCmdCopyAccelerationStructureToMemoryKHR = PFN_vkCmdCopyAccelerationStructureToMemoryKHR( 1165 vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); 1166 vkCmdCopyMemoryToAccelerationStructureKHR = PFN_vkCmdCopyMemoryToAccelerationStructureKHR( 1167 vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); 1168 vkGetAccelerationStructureDeviceAddressKHR = PFN_vkGetAccelerationStructureDeviceAddressKHR( 1169 vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) ); 1170 vkCmdWriteAccelerationStructuresPropertiesKHR = PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( 1171 vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); 1172 vkGetDeviceAccelerationStructureCompatibilityKHR = PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( 1173 vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); 1174 vkGetAccelerationStructureBuildSizesKHR = PFN_vkGetAccelerationStructureBuildSizesKHR( 1175 vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) ); 1176 1177 //=== VK_KHR_bind_memory2 === 1178 vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) ); 1179 if ( !vkBindBufferMemory2 ) 1180 vkBindBufferMemory2 = vkBindBufferMemory2KHR; 1181 vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) ); 1182 if ( !vkBindImageMemory2 ) 1183 vkBindImageMemory2 = vkBindImageMemory2KHR; 1184 1185 //=== VK_KHR_buffer_device_address === 1186 vkGetBufferDeviceAddressKHR = 1187 PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) ); 1188 if ( !vkGetBufferDeviceAddress ) 1189 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; 1190 vkGetBufferOpaqueCaptureAddressKHR = 1191 PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) ); 1192 if ( !vkGetBufferOpaqueCaptureAddress ) 1193 vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; 1194 vkGetDeviceMemoryOpaqueCaptureAddressKHR = PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( 1195 vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); 1196 if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) 1197 vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; 1198 1199 //=== VK_KHR_copy_commands2 === 1200 vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) ); 1201 vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) ); 1202 vkCmdCopyBufferToImage2KHR = 1203 PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) ); 1204 vkCmdCopyImageToBuffer2KHR = 1205 PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) ); 1206 vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) ); 1207 vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) ); 1208 1209 //=== VK_KHR_create_renderpass2 === 1210 vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) ); 1211 if ( !vkCreateRenderPass2 ) 1212 vkCreateRenderPass2 = vkCreateRenderPass2KHR; 1213 vkCmdBeginRenderPass2KHR = 1214 PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) ); 1215 if ( !vkCmdBeginRenderPass2 ) 1216 vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; 1217 vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) ); 1218 if ( !vkCmdNextSubpass2 ) 1219 vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; 1220 vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) ); 1221 if ( !vkCmdEndRenderPass2 ) 1222 vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; 1223 1224 //=== VK_KHR_deferred_host_operations === 1225 vkCreateDeferredOperationKHR = 1226 PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) ); 1227 vkDestroyDeferredOperationKHR = 1228 PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) ); 1229 vkGetDeferredOperationMaxConcurrencyKHR = PFN_vkGetDeferredOperationMaxConcurrencyKHR( 1230 vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); 1231 vkGetDeferredOperationResultKHR = 1232 PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) ); 1233 vkDeferredOperationJoinKHR = 1234 PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) ); 1235 1236 //=== VK_KHR_descriptor_update_template === 1237 vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( 1238 vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) ); 1239 if ( !vkCreateDescriptorUpdateTemplate ) 1240 vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; 1241 vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( 1242 vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) ); 1243 if ( !vkDestroyDescriptorUpdateTemplate ) 1244 vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; 1245 vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( 1246 vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) ); 1247 if ( !vkUpdateDescriptorSetWithTemplate ) 1248 vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; 1249 vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR( 1250 vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); 1251 1252 //=== VK_KHR_device_group === 1253 vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( 1254 vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); 1255 if ( !vkGetDeviceGroupPeerMemoryFeatures ) 1256 vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; 1257 vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) ); 1258 if ( !vkCmdSetDeviceMask ) 1259 vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; 1260 vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) ); 1261 if ( !vkCmdDispatchBase ) 1262 vkCmdDispatchBase = vkCmdDispatchBaseKHR; 1263 vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( 1264 vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); 1265 vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( 1266 vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); 1267 vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) ); 1268 1269 //=== VK_KHR_display_swapchain === 1270 vkCreateSharedSwapchainsKHR = 1271 PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) ); 1272 1273 //=== VK_KHR_draw_indirect_count === 1274 vkCmdDrawIndirectCountKHR = 1275 PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) ); 1276 if ( !vkCmdDrawIndirectCount ) 1277 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; 1278 vkCmdDrawIndexedIndirectCountKHR = 1279 PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) ); 1280 if ( !vkCmdDrawIndexedIndirectCount ) 1281 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; 1282 1283 //=== VK_KHR_dynamic_rendering === 1284 vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) ); 1285 vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) ); 1286 1287 //=== VK_KHR_external_fence_fd === 1288 vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) ); 1289 vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) ); 1290 1291 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 1292 //=== VK_KHR_external_fence_win32 === 1293 vkImportFenceWin32HandleKHR = 1294 PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) ); 1295 vkGetFenceWin32HandleKHR = 1296 PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) ); 1297 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 1298 1299 //=== VK_KHR_external_memory_fd === 1300 vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) ); 1301 vkGetMemoryFdPropertiesKHR = 1302 PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) ); 1303 1304 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 1305 //=== VK_KHR_external_memory_win32 === 1306 vkGetMemoryWin32HandleKHR = 1307 PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) ); 1308 vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( 1309 vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) ); 1310 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 1311 1312 //=== VK_KHR_external_semaphore_fd === 1313 vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) ); 1314 vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) ); 1315 1316 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 1317 //=== VK_KHR_external_semaphore_win32 === 1318 vkImportSemaphoreWin32HandleKHR = 1319 PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) ); 1320 vkGetSemaphoreWin32HandleKHR = 1321 PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) ); 1322 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 1323 1324 //=== VK_KHR_fragment_shading_rate === 1325 vkCmdSetFragmentShadingRateKHR = 1326 PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) ); 1327 1328 //=== VK_KHR_get_memory_requirements2 === 1329 vkGetImageMemoryRequirements2KHR = 1330 PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) ); 1331 if ( !vkGetImageMemoryRequirements2 ) 1332 vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; 1333 vkGetBufferMemoryRequirements2KHR = 1334 PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) ); 1335 if ( !vkGetBufferMemoryRequirements2 ) 1336 vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; 1337 vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( 1338 vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) ); 1339 if ( !vkGetImageSparseMemoryRequirements2 ) 1340 vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; 1341 1342 //=== VK_KHR_maintenance1 === 1343 vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) ); 1344 if ( !vkTrimCommandPool ) 1345 vkTrimCommandPool = vkTrimCommandPoolKHR; 1346 1347 //=== VK_KHR_maintenance3 === 1348 vkGetDescriptorSetLayoutSupportKHR = 1349 PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) ); 1350 if ( !vkGetDescriptorSetLayoutSupport ) 1351 vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; 1352 1353 //=== VK_KHR_maintenance4 === 1354 vkGetDeviceBufferMemoryRequirementsKHR = PFN_vkGetDeviceBufferMemoryRequirementsKHR( 1355 vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); 1356 vkGetDeviceImageMemoryRequirementsKHR = PFN_vkGetDeviceImageMemoryRequirementsKHR( 1357 vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) ); 1358 vkGetDeviceImageSparseMemoryRequirementsKHR = PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( 1359 vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); 1360 1361 //=== VK_KHR_performance_query === 1362 vkAcquireProfilingLockKHR = 1363 PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) ); 1364 vkReleaseProfilingLockKHR = 1365 PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) ); 1366 1367 //=== VK_KHR_pipeline_executable_properties === 1368 vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( 1369 vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) ); 1370 vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( 1371 vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) ); 1372 vkGetPipelineExecutableInternalRepresentationsKHR = PFN_vkGetPipelineExecutableInternalRepresentationsKHR( 1373 vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); 1374 1375 //=== VK_KHR_present_wait === 1376 vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) ); 1377 1378 //=== VK_KHR_push_descriptor === 1379 vkCmdPushDescriptorSetKHR = 1380 PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) ); 1381 1382 //=== VK_KHR_ray_tracing_pipeline === 1383 vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) ); 1384 vkCreateRayTracingPipelinesKHR = 1385 PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) ); 1386 vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR( 1387 vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) ); 1388 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( 1389 vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); 1390 vkCmdTraceRaysIndirectKHR = 1391 PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) ); 1392 vkGetRayTracingShaderGroupStackSizeKHR = PFN_vkGetRayTracingShaderGroupStackSizeKHR( 1393 vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); 1394 vkCmdSetRayTracingPipelineStackSizeKHR = PFN_vkCmdSetRayTracingPipelineStackSizeKHR( 1395 vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); 1396 1397 //=== VK_KHR_sampler_ycbcr_conversion === 1398 vkCreateSamplerYcbcrConversionKHR = 1399 PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) ); 1400 if ( !vkCreateSamplerYcbcrConversion ) 1401 vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; 1402 vkDestroySamplerYcbcrConversionKHR = 1403 PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) ); 1404 if ( !vkDestroySamplerYcbcrConversion ) 1405 vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; 1406 1407 //=== VK_KHR_shared_presentable_image === 1408 vkGetSwapchainStatusKHR = 1409 PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) ); 1410 1411 //=== VK_KHR_swapchain === 1412 vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) ); 1413 vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) ); 1414 vkGetSwapchainImagesKHR = 1415 PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) ); 1416 vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) ); 1417 vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) ); 1418 1419 //=== VK_KHR_synchronization2 === 1420 vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) ); 1421 vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) ); 1422 vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) ); 1423 vkCmdPipelineBarrier2KHR = 1424 PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) ); 1425 vkCmdWriteTimestamp2KHR = 1426 PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) ); 1427 vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) ); 1428 vkCmdWriteBufferMarker2AMD = 1429 PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) ); 1430 vkGetQueueCheckpointData2NV = 1431 PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) ); 1432 1433 //=== VK_KHR_timeline_semaphore === 1434 vkGetSemaphoreCounterValueKHR = 1435 PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) ); 1436 if ( !vkGetSemaphoreCounterValue ) 1437 vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; 1438 vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) ); 1439 if ( !vkWaitSemaphores ) 1440 vkWaitSemaphores = vkWaitSemaphoresKHR; 1441 vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) ); 1442 if ( !vkSignalSemaphore ) 1443 vkSignalSemaphore = vkSignalSemaphoreKHR; 1444 1445 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 1446 //=== VK_KHR_video_decode_queue === 1447 vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) ); 1448 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 1449 1450 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 1451 //=== VK_KHR_video_encode_queue === 1452 vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) ); 1453 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 1454 1455 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 1456 //=== VK_KHR_video_queue === 1457 vkCreateVideoSessionKHR = 1458 PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) ); 1459 vkDestroyVideoSessionKHR = 1460 PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) ); 1461 vkGetVideoSessionMemoryRequirementsKHR = PFN_vkGetVideoSessionMemoryRequirementsKHR( 1462 vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) ); 1463 vkBindVideoSessionMemoryKHR = 1464 PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) ); 1465 vkCreateVideoSessionParametersKHR = 1466 PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) ); 1467 vkUpdateVideoSessionParametersKHR = 1468 PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) ); 1469 vkDestroyVideoSessionParametersKHR = 1470 PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) ); 1471 vkCmdBeginVideoCodingKHR = 1472 PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) ); 1473 vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) ); 1474 vkCmdControlVideoCodingKHR = 1475 PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) ); 1476 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 1477 1478 //=== VK_NVX_binary_import === 1479 vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) ); 1480 vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) ); 1481 vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) ); 1482 vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) ); 1483 vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) ); 1484 1485 //=== VK_NVX_image_view_handle === 1486 vkGetImageViewHandleNVX = 1487 PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) ); 1488 vkGetImageViewAddressNVX = 1489 PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) ); 1490 1491 //=== VK_NV_clip_space_w_scaling === 1492 vkCmdSetViewportWScalingNV = 1493 PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) ); 1494 1495 //=== VK_NV_device_diagnostic_checkpoints === 1496 vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) ); 1497 vkGetQueueCheckpointDataNV = 1498 PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) ); 1499 1500 //=== VK_NV_device_generated_commands === 1501 vkGetGeneratedCommandsMemoryRequirementsNV = PFN_vkGetGeneratedCommandsMemoryRequirementsNV( 1502 vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); 1503 vkCmdPreprocessGeneratedCommandsNV = 1504 PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) ); 1505 vkCmdExecuteGeneratedCommandsNV = 1506 PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) ); 1507 vkCmdBindPipelineShaderGroupNV = 1508 PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) ); 1509 vkCreateIndirectCommandsLayoutNV = 1510 PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) ); 1511 vkDestroyIndirectCommandsLayoutNV = 1512 PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) ); 1513 1514 //=== VK_NV_external_memory_rdma === 1515 vkGetMemoryRemoteAddressNV = 1516 PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) ); 1517 1518 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 1519 //=== VK_NV_external_memory_win32 === 1520 vkGetMemoryWin32HandleNV = 1521 PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) ); 1522 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 1523 1524 //=== VK_NV_fragment_shading_rate_enums === 1525 vkCmdSetFragmentShadingRateEnumNV = 1526 PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) ); 1527 1528 //=== VK_NV_mesh_shader === 1529 vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) ); 1530 vkCmdDrawMeshTasksIndirectNV = 1531 PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) ); 1532 vkCmdDrawMeshTasksIndirectCountNV = 1533 PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) ); 1534 1535 //=== VK_NV_ray_tracing === 1536 vkCreateAccelerationStructureNV = 1537 PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) ); 1538 vkDestroyAccelerationStructureNV = 1539 PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) ); 1540 vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV( 1541 vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); 1542 vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( 1543 vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) ); 1544 vkCmdBuildAccelerationStructureNV = 1545 PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) ); 1546 vkCmdCopyAccelerationStructureNV = 1547 PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) ); 1548 vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) ); 1549 vkCreateRayTracingPipelinesNV = 1550 PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) ); 1551 vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( 1552 vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) ); 1553 if ( !vkGetRayTracingShaderGroupHandlesKHR ) 1554 vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; 1555 vkGetAccelerationStructureHandleNV = 1556 PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) ); 1557 vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV( 1558 vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); 1559 vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) ); 1560 1561 //=== VK_NV_scissor_exclusive === 1562 vkCmdSetExclusiveScissorNV = 1563 PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) ); 1564 1565 //=== VK_NV_shading_rate_image === 1566 vkCmdBindShadingRateImageNV = 1567 PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) ); 1568 vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( 1569 vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) ); 1570 vkCmdSetCoarseSampleOrderNV = 1571 PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) ); 1572 } 1573 1574 public: 1575 //=== VK_VERSION_1_0 === 1576 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; 1577 PFN_vkDestroyDevice vkDestroyDevice = 0; 1578 PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; 1579 PFN_vkQueueSubmit vkQueueSubmit = 0; 1580 PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; 1581 PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; 1582 PFN_vkAllocateMemory vkAllocateMemory = 0; 1583 PFN_vkFreeMemory vkFreeMemory = 0; 1584 PFN_vkMapMemory vkMapMemory = 0; 1585 PFN_vkUnmapMemory vkUnmapMemory = 0; 1586 PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; 1587 PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; 1588 PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; 1589 PFN_vkBindBufferMemory vkBindBufferMemory = 0; 1590 PFN_vkBindImageMemory vkBindImageMemory = 0; 1591 PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; 1592 PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; 1593 PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; 1594 PFN_vkQueueBindSparse vkQueueBindSparse = 0; 1595 PFN_vkCreateFence vkCreateFence = 0; 1596 PFN_vkDestroyFence vkDestroyFence = 0; 1597 PFN_vkResetFences vkResetFences = 0; 1598 PFN_vkGetFenceStatus vkGetFenceStatus = 0; 1599 PFN_vkWaitForFences vkWaitForFences = 0; 1600 PFN_vkCreateSemaphore vkCreateSemaphore = 0; 1601 PFN_vkDestroySemaphore vkDestroySemaphore = 0; 1602 PFN_vkCreateEvent vkCreateEvent = 0; 1603 PFN_vkDestroyEvent vkDestroyEvent = 0; 1604 PFN_vkGetEventStatus vkGetEventStatus = 0; 1605 PFN_vkSetEvent vkSetEvent = 0; 1606 PFN_vkResetEvent vkResetEvent = 0; 1607 PFN_vkCreateQueryPool vkCreateQueryPool = 0; 1608 PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; 1609 PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; 1610 PFN_vkCreateBuffer vkCreateBuffer = 0; 1611 PFN_vkDestroyBuffer vkDestroyBuffer = 0; 1612 PFN_vkCreateBufferView vkCreateBufferView = 0; 1613 PFN_vkDestroyBufferView vkDestroyBufferView = 0; 1614 PFN_vkCreateImage vkCreateImage = 0; 1615 PFN_vkDestroyImage vkDestroyImage = 0; 1616 PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; 1617 PFN_vkCreateImageView vkCreateImageView = 0; 1618 PFN_vkDestroyImageView vkDestroyImageView = 0; 1619 PFN_vkCreateShaderModule vkCreateShaderModule = 0; 1620 PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; 1621 PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; 1622 PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; 1623 PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; 1624 PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; 1625 PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; 1626 PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; 1627 PFN_vkDestroyPipeline vkDestroyPipeline = 0; 1628 PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; 1629 PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; 1630 PFN_vkCreateSampler vkCreateSampler = 0; 1631 PFN_vkDestroySampler vkDestroySampler = 0; 1632 PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; 1633 PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; 1634 PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; 1635 PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; 1636 PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; 1637 PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; 1638 PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; 1639 PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; 1640 PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; 1641 PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; 1642 PFN_vkCreateRenderPass vkCreateRenderPass = 0; 1643 PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; 1644 PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; 1645 PFN_vkCreateCommandPool vkCreateCommandPool = 0; 1646 PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; 1647 PFN_vkResetCommandPool vkResetCommandPool = 0; 1648 PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; 1649 PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; 1650 PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; 1651 PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; 1652 PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; 1653 PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; 1654 PFN_vkCmdSetViewport vkCmdSetViewport = 0; 1655 PFN_vkCmdSetScissor vkCmdSetScissor = 0; 1656 PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; 1657 PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; 1658 PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; 1659 PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; 1660 PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; 1661 PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; 1662 PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; 1663 PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; 1664 PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; 1665 PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; 1666 PFN_vkCmdDraw vkCmdDraw = 0; 1667 PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; 1668 PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; 1669 PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; 1670 PFN_vkCmdDispatch vkCmdDispatch = 0; 1671 PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; 1672 PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; 1673 PFN_vkCmdCopyImage vkCmdCopyImage = 0; 1674 PFN_vkCmdBlitImage vkCmdBlitImage = 0; 1675 PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; 1676 PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; 1677 PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; 1678 PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; 1679 PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; 1680 PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; 1681 PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; 1682 PFN_vkCmdResolveImage vkCmdResolveImage = 0; 1683 PFN_vkCmdSetEvent vkCmdSetEvent = 0; 1684 PFN_vkCmdResetEvent vkCmdResetEvent = 0; 1685 PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; 1686 PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; 1687 PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; 1688 PFN_vkCmdEndQuery vkCmdEndQuery = 0; 1689 PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; 1690 PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; 1691 PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; 1692 PFN_vkCmdPushConstants vkCmdPushConstants = 0; 1693 PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; 1694 PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; 1695 PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; 1696 PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; 1697 1698 //=== VK_VERSION_1_1 === 1699 PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; 1700 PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; 1701 PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; 1702 PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; 1703 PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; 1704 PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; 1705 PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; 1706 PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; 1707 PFN_vkTrimCommandPool vkTrimCommandPool = 0; 1708 PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; 1709 PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; 1710 PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; 1711 PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; 1712 PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; 1713 PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; 1714 PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; 1715 1716 //=== VK_VERSION_1_2 === 1717 PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0; 1718 PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0; 1719 PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; 1720 PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0; 1721 PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0; 1722 PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0; 1723 PFN_vkResetQueryPool vkResetQueryPool = 0; 1724 PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0; 1725 PFN_vkWaitSemaphores vkWaitSemaphores = 0; 1726 PFN_vkSignalSemaphore vkSignalSemaphore = 0; 1727 PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0; 1728 PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0; 1729 PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0; 1730 1731 //=== VK_AMD_buffer_marker === 1732 PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; 1733 1734 //=== VK_AMD_display_native_hdr === 1735 PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; 1736 1737 //=== VK_AMD_draw_indirect_count === 1738 PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; 1739 PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; 1740 1741 //=== VK_AMD_shader_info === 1742 PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; 1743 1744 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1745 //=== VK_ANDROID_external_memory_android_hardware_buffer === 1746 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; 1747 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; 1748 # else 1749 PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; 1750 PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; 1751 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1752 1753 //=== VK_EXT_buffer_device_address === 1754 PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; 1755 1756 //=== VK_EXT_calibrated_timestamps === 1757 PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0; 1758 1759 //=== VK_EXT_color_write_enable === 1760 PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; 1761 1762 //=== VK_EXT_conditional_rendering === 1763 PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; 1764 PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; 1765 1766 //=== VK_EXT_debug_marker === 1767 PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; 1768 PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; 1769 PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; 1770 PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; 1771 PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; 1772 1773 //=== VK_EXT_debug_utils === 1774 PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; 1775 PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; 1776 PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; 1777 PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; 1778 PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; 1779 PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; 1780 PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; 1781 PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; 1782 1783 //=== VK_EXT_discard_rectangles === 1784 PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; 1785 1786 //=== VK_EXT_display_control === 1787 PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; 1788 PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; 1789 PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; 1790 PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; 1791 1792 //=== VK_EXT_extended_dynamic_state === 1793 PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; 1794 PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; 1795 PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; 1796 PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0; 1797 PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0; 1798 PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0; 1799 PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0; 1800 PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0; 1801 PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; 1802 PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; 1803 PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0; 1804 PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0; 1805 1806 //=== VK_EXT_extended_dynamic_state2 === 1807 PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; 1808 PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; 1809 PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; 1810 PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; 1811 PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; 1812 1813 //=== VK_EXT_external_memory_host === 1814 PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; 1815 1816 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 1817 //=== VK_EXT_full_screen_exclusive === 1818 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; 1819 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; 1820 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; 1821 # else 1822 PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; 1823 PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; 1824 PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; 1825 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 1826 1827 //=== VK_EXT_hdr_metadata === 1828 PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; 1829 1830 //=== VK_EXT_host_query_reset === 1831 PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; 1832 1833 //=== VK_EXT_image_drm_format_modifier === 1834 PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; 1835 1836 //=== VK_EXT_line_rasterization === 1837 PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; 1838 1839 //=== VK_EXT_multi_draw === 1840 PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0; 1841 PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0; 1842 1843 //=== VK_EXT_pageable_device_local_memory === 1844 PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0; 1845 1846 //=== VK_EXT_private_data === 1847 PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0; 1848 PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0; 1849 PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0; 1850 PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0; 1851 1852 //=== VK_EXT_sample_locations === 1853 PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; 1854 1855 //=== VK_EXT_transform_feedback === 1856 PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; 1857 PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; 1858 PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; 1859 PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; 1860 PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; 1861 PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; 1862 1863 //=== VK_EXT_validation_cache === 1864 PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; 1865 PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; 1866 PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; 1867 PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; 1868 1869 //=== VK_EXT_vertex_input_dynamic_state === 1870 PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0; 1871 1872 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1873 //=== VK_FUCHSIA_buffer_collection === 1874 PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0; 1875 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0; 1876 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0; 1877 PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; 1878 PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; 1879 # else 1880 PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; 1881 PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; 1882 PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; 1883 PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; 1884 PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; 1885 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1886 1887 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1888 //=== VK_FUCHSIA_external_memory === 1889 PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; 1890 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; 1891 # else 1892 PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; 1893 PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; 1894 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1895 1896 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1897 //=== VK_FUCHSIA_external_semaphore === 1898 PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; 1899 PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; 1900 # else 1901 PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; 1902 PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; 1903 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1904 1905 //=== VK_GOOGLE_display_timing === 1906 PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; 1907 PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; 1908 1909 //=== VK_HUAWEI_invocation_mask === 1910 PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0; 1911 1912 //=== VK_HUAWEI_subpass_shading === 1913 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0; 1914 PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0; 1915 1916 //=== VK_INTEL_performance_query === 1917 PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; 1918 PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; 1919 PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; 1920 PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; 1921 PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; 1922 PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; 1923 PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; 1924 PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; 1925 PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; 1926 1927 //=== VK_KHR_acceleration_structure === 1928 PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0; 1929 PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0; 1930 PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0; 1931 PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0; 1932 PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0; 1933 PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0; 1934 PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0; 1935 PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0; 1936 PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0; 1937 PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0; 1938 PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0; 1939 PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; 1940 PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0; 1941 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0; 1942 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0; 1943 PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0; 1944 1945 //=== VK_KHR_bind_memory2 === 1946 PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; 1947 PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; 1948 1949 //=== VK_KHR_buffer_device_address === 1950 PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0; 1951 PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0; 1952 PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0; 1953 1954 //=== VK_KHR_copy_commands2 === 1955 PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0; 1956 PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0; 1957 PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0; 1958 PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; 1959 PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0; 1960 PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0; 1961 1962 //=== VK_KHR_create_renderpass2 === 1963 PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; 1964 PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; 1965 PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0; 1966 PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; 1967 1968 //=== VK_KHR_deferred_host_operations === 1969 PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; 1970 PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; 1971 PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0; 1972 PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0; 1973 PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0; 1974 1975 //=== VK_KHR_descriptor_update_template === 1976 PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; 1977 PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; 1978 PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; 1979 PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; 1980 1981 //=== VK_KHR_device_group === 1982 PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; 1983 PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; 1984 PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; 1985 PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; 1986 PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; 1987 PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; 1988 1989 //=== VK_KHR_display_swapchain === 1990 PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; 1991 1992 //=== VK_KHR_draw_indirect_count === 1993 PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; 1994 PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; 1995 1996 //=== VK_KHR_dynamic_rendering === 1997 PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0; 1998 PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0; 1999 2000 //=== VK_KHR_external_fence_fd === 2001 PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; 2002 PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; 2003 2004 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2005 //=== VK_KHR_external_fence_win32 === 2006 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; 2007 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; 2008 # else 2009 PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; 2010 PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; 2011 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2012 2013 //=== VK_KHR_external_memory_fd === 2014 PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; 2015 PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; 2016 2017 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2018 //=== VK_KHR_external_memory_win32 === 2019 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; 2020 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; 2021 # else 2022 PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; 2023 PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; 2024 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2025 2026 //=== VK_KHR_external_semaphore_fd === 2027 PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; 2028 PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; 2029 2030 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2031 //=== VK_KHR_external_semaphore_win32 === 2032 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; 2033 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; 2034 # else 2035 PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; 2036 PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; 2037 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2038 2039 //=== VK_KHR_fragment_shading_rate === 2040 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0; 2041 2042 //=== VK_KHR_get_memory_requirements2 === 2043 PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; 2044 PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; 2045 PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; 2046 2047 //=== VK_KHR_maintenance1 === 2048 PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; 2049 2050 //=== VK_KHR_maintenance3 === 2051 PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; 2052 2053 //=== VK_KHR_maintenance4 === 2054 PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0; 2055 PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0; 2056 PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0; 2057 2058 //=== VK_KHR_performance_query === 2059 PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; 2060 PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; 2061 2062 //=== VK_KHR_pipeline_executable_properties === 2063 PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; 2064 PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; 2065 PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; 2066 2067 //=== VK_KHR_present_wait === 2068 PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0; 2069 2070 //=== VK_KHR_push_descriptor === 2071 PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; 2072 2073 //=== VK_KHR_ray_tracing_pipeline === 2074 PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0; 2075 PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0; 2076 PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0; 2077 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0; 2078 PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0; 2079 PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0; 2080 PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; 2081 2082 //=== VK_KHR_sampler_ycbcr_conversion === 2083 PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; 2084 PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; 2085 2086 //=== VK_KHR_shared_presentable_image === 2087 PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; 2088 2089 //=== VK_KHR_swapchain === 2090 PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; 2091 PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; 2092 PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; 2093 PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; 2094 PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; 2095 2096 //=== VK_KHR_synchronization2 === 2097 PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0; 2098 PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0; 2099 PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0; 2100 PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0; 2101 PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0; 2102 PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0; 2103 PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0; 2104 PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0; 2105 2106 //=== VK_KHR_timeline_semaphore === 2107 PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0; 2108 PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; 2109 PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; 2110 2111 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2112 //=== VK_KHR_video_decode_queue === 2113 PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0; 2114 # else 2115 PFN_dummy vkCmdDecodeVideoKHR_placeholder = 0; 2116 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2117 2118 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2119 //=== VK_KHR_video_encode_queue === 2120 PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; 2121 # else 2122 PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0; 2123 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2124 2125 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2126 //=== VK_KHR_video_queue === 2127 PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0; 2128 PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0; 2129 PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0; 2130 PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0; 2131 PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0; 2132 PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0; 2133 PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0; 2134 PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0; 2135 PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0; 2136 PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0; 2137 # else 2138 PFN_dummy vkCreateVideoSessionKHR_placeholder = 0; 2139 PFN_dummy vkDestroyVideoSessionKHR_placeholder = 0; 2140 PFN_dummy vkGetVideoSessionMemoryRequirementsKHR_placeholder = 0; 2141 PFN_dummy vkBindVideoSessionMemoryKHR_placeholder = 0; 2142 PFN_dummy vkCreateVideoSessionParametersKHR_placeholder = 0; 2143 PFN_dummy vkUpdateVideoSessionParametersKHR_placeholder = 0; 2144 PFN_dummy vkDestroyVideoSessionParametersKHR_placeholder = 0; 2145 PFN_dummy vkCmdBeginVideoCodingKHR_placeholder = 0; 2146 PFN_dummy vkCmdEndVideoCodingKHR_placeholder = 0; 2147 PFN_dummy vkCmdControlVideoCodingKHR_placeholder = 0; 2148 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2149 2150 //=== VK_NVX_binary_import === 2151 PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0; 2152 PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0; 2153 PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0; 2154 PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0; 2155 PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; 2156 2157 //=== VK_NVX_image_view_handle === 2158 PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; 2159 PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; 2160 2161 //=== VK_NV_clip_space_w_scaling === 2162 PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; 2163 2164 //=== VK_NV_device_diagnostic_checkpoints === 2165 PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; 2166 PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0; 2167 2168 //=== VK_NV_device_generated_commands === 2169 PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0; 2170 PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0; 2171 PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0; 2172 PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0; 2173 PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0; 2174 PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0; 2175 2176 //=== VK_NV_external_memory_rdma === 2177 PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0; 2178 2179 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2180 //=== VK_NV_external_memory_win32 === 2181 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; 2182 # else 2183 PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; 2184 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2185 2186 //=== VK_NV_fragment_shading_rate_enums === 2187 PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; 2188 2189 //=== VK_NV_mesh_shader === 2190 PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; 2191 PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; 2192 PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; 2193 2194 //=== VK_NV_ray_tracing === 2195 PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; 2196 PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; 2197 PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; 2198 PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; 2199 PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; 2200 PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; 2201 PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; 2202 PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; 2203 PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; 2204 PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; 2205 PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; 2206 PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; 2207 2208 //=== VK_NV_scissor_exclusive === 2209 PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; 2210 2211 //=== VK_NV_shading_rate_image === 2212 PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; 2213 PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; 2214 PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; 2215 }; 2216 2217 //======================================== 2218 //=== RAII HANDLE forward declarations === 2219 //======================================== 2220 2221 //=== VK_VERSION_1_0 === 2222 class Instance; 2223 class PhysicalDevice; 2224 class Device; 2225 class Queue; 2226 class DeviceMemory; 2227 class Fence; 2228 class Semaphore; 2229 class Event; 2230 class QueryPool; 2231 class Buffer; 2232 class BufferView; 2233 class Image; 2234 class ImageView; 2235 class ShaderModule; 2236 class PipelineCache; 2237 class Pipeline; 2238 class PipelineLayout; 2239 class Sampler; 2240 class DescriptorPool; 2241 class DescriptorSet; 2242 class DescriptorSetLayout; 2243 class Framebuffer; 2244 class RenderPass; 2245 class CommandPool; 2246 class CommandBuffer; 2247 2248 //=== VK_VERSION_1_1 === 2249 class SamplerYcbcrConversion; 2250 class DescriptorUpdateTemplate; 2251 2252 //=== VK_KHR_surface === 2253 class SurfaceKHR; 2254 2255 //=== VK_KHR_swapchain === 2256 class SwapchainKHR; 2257 2258 //=== VK_KHR_display === 2259 class DisplayKHR; 2260 class DisplayModeKHR; 2261 2262 //=== VK_EXT_debug_report === 2263 class DebugReportCallbackEXT; 2264 2265 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2266 //=== VK_KHR_video_queue === 2267 class VideoSessionKHR; 2268 class VideoSessionParametersKHR; 2269 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2270 2271 //=== VK_NVX_binary_import === 2272 class CuModuleNVX; 2273 class CuFunctionNVX; 2274 2275 //=== VK_EXT_debug_utils === 2276 class DebugUtilsMessengerEXT; 2277 2278 //=== VK_KHR_acceleration_structure === 2279 class AccelerationStructureKHR; 2280 2281 //=== VK_EXT_validation_cache === 2282 class ValidationCacheEXT; 2283 2284 //=== VK_NV_ray_tracing === 2285 class AccelerationStructureNV; 2286 2287 //=== VK_INTEL_performance_query === 2288 class PerformanceConfigurationINTEL; 2289 2290 //=== VK_KHR_deferred_host_operations === 2291 class DeferredOperationKHR; 2292 2293 //=== VK_NV_device_generated_commands === 2294 class IndirectCommandsLayoutNV; 2295 2296 //=== VK_EXT_private_data === 2297 class PrivateDataSlotEXT; 2298 2299 # if defined( VK_USE_PLATFORM_FUCHSIA ) 2300 //=== VK_FUCHSIA_buffer_collection === 2301 class BufferCollectionFUCHSIA; 2302 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 2303 2304 //==================== 2305 //=== RAII HANDLES === 2306 //==================== 2307 2308 class Context 2309 { 2310 public: 2311 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL Context()2312 Context() 2313 : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher( 2314 m_dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" ) ) ) 2315 # else 2316 Context( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) 2317 : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher( getInstanceProcAddr ) ) 2318 # endif 2319 {} 2320 2321 ~Context() = default; 2322 2323 Context( Context const & ) = delete; Context(Context && rhs)2324 Context( Context && rhs ) VULKAN_HPP_NOEXCEPT 2325 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 2326 : m_dynamicLoader( std::move( rhs.m_dynamicLoader ) ) 2327 , m_dispatcher( rhs.m_dispatcher.release() ) 2328 # else 2329 : m_dispatcher( rhs.m_dispatcher.release() ) 2330 # endif 2331 {} 2332 Context & operator=( Context const & ) = delete; operator =(Context && rhs)2333 Context & operator =( Context && rhs ) VULKAN_HPP_NOEXCEPT 2334 { 2335 if ( this != &rhs ) 2336 { 2337 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 2338 m_dynamicLoader = std::move( rhs.m_dynamicLoader ); 2339 # endif 2340 m_dispatcher.reset( rhs.m_dispatcher.release() ); 2341 } 2342 return *this; 2343 } 2344 2345 //=== VK_VERSION_1_0 === 2346 2347 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Instance createInstance( 2348 VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo, 2349 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2350 2351 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> enumerateInstanceExtensionProperties( 2352 Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 2353 2354 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateInstanceLayerProperties() const; 2355 2356 //=== VK_VERSION_1_1 === 2357 2358 VULKAN_HPP_NODISCARD uint32_t enumerateInstanceVersion() const; 2359 getDispatcher() const2360 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const 2361 { 2362 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 2363 return &*m_dispatcher; 2364 } 2365 2366 private: 2367 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 2368 VULKAN_HPP_NAMESPACE::DynamicLoader m_dynamicLoader; 2369 # endif 2370 std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher> m_dispatcher; 2371 }; 2372 2373 class Instance 2374 { 2375 public: 2376 using CType = VkInstance; 2377 2378 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 2379 VULKAN_HPP_NAMESPACE::ObjectType::eInstance; 2380 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 2381 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance; 2382 2383 public: Instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context,VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)2384 Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context, 2385 VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo, 2386 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 2387 : m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 2388 { 2389 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 2390 context.getDispatcher()->vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ), 2391 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 2392 reinterpret_cast<VkInstance *>( &m_instance ) ) ); 2393 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 2394 { 2395 throwResultException( result, "vkCreateInstance" ); 2396 } 2397 m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher( 2398 context.getDispatcher()->vkGetInstanceProcAddr, static_cast<VkInstance>( m_instance ) ) ); 2399 } 2400 Instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context,VkInstance instance,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)2401 Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context, 2402 VkInstance instance, 2403 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 2404 : m_instance( instance ) 2405 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 2406 { 2407 m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher( 2408 context.getDispatcher()->vkGetInstanceProcAddr, static_cast<VkInstance>( m_instance ) ) ); 2409 } 2410 Instance(std::nullptr_t)2411 Instance( std::nullptr_t ) {} 2412 ~Instance()2413 ~Instance() 2414 { 2415 if ( m_instance ) 2416 { 2417 getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ), 2418 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 2419 } 2420 } 2421 2422 Instance() = delete; 2423 Instance( Instance const & ) = delete; Instance(Instance && rhs)2424 Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT 2425 : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) 2426 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 2427 , m_dispatcher( rhs.m_dispatcher.release() ) 2428 {} 2429 Instance & operator=( Instance const & ) = delete; operator =(Instance && rhs)2430 Instance & operator =( Instance && rhs ) VULKAN_HPP_NOEXCEPT 2431 { 2432 if ( this != &rhs ) 2433 { 2434 if ( m_instance ) 2435 { 2436 getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ), 2437 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 2438 } 2439 m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); 2440 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 2441 m_dispatcher.reset( rhs.m_dispatcher.release() ); 2442 } 2443 return *this; 2444 } 2445 operator *() const2446 VULKAN_HPP_NAMESPACE::Instance const & operator*() const VULKAN_HPP_NOEXCEPT 2447 { 2448 return m_instance; 2449 } 2450 getDispatcher() const2451 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 2452 { 2453 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 2454 return &*m_dispatcher; 2455 } 2456 2457 //=== VK_VERSION_1_0 === 2458 2459 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> enumeratePhysicalDevices() const; 2460 2461 VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; 2462 2463 //=== VK_VERSION_1_1 === 2464 2465 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> 2466 enumeratePhysicalDeviceGroups() const; 2467 2468 //=== VK_KHR_display === 2469 2470 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createDisplayPlaneSurfaceKHR( 2471 VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo, 2472 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2473 2474 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 2475 //=== VK_KHR_xlib_surface === 2476 2477 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createXlibSurfaceKHR( 2478 VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo, 2479 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2480 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 2481 2482 # if defined( VK_USE_PLATFORM_XCB_KHR ) 2483 //=== VK_KHR_xcb_surface === 2484 2485 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createXcbSurfaceKHR( 2486 VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo, 2487 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2488 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 2489 2490 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 2491 //=== VK_KHR_wayland_surface === 2492 2493 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createWaylandSurfaceKHR( 2494 VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo, 2495 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2496 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 2497 2498 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 2499 //=== VK_KHR_android_surface === 2500 2501 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createAndroidSurfaceKHR( 2502 VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo, 2503 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2504 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 2505 2506 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2507 //=== VK_KHR_win32_surface === 2508 2509 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createWin32SurfaceKHR( 2510 VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo, 2511 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2512 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2513 2514 //=== VK_EXT_debug_report === 2515 2516 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT createDebugReportCallbackEXT( 2517 VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo, 2518 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2519 2520 void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, 2521 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, 2522 uint64_t object, 2523 size_t location, 2524 int32_t messageCode, 2525 const std::string & layerPrefix, 2526 const std::string & message ) const VULKAN_HPP_NOEXCEPT; 2527 2528 # if defined( VK_USE_PLATFORM_GGP ) 2529 //=== VK_GGP_stream_descriptor_surface === 2530 2531 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createStreamDescriptorSurfaceGGP( 2532 VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, 2533 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2534 # endif /*VK_USE_PLATFORM_GGP*/ 2535 2536 # if defined( VK_USE_PLATFORM_VI_NN ) 2537 //=== VK_NN_vi_surface === 2538 2539 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createViSurfaceNN( 2540 VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, 2541 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2542 # endif /*VK_USE_PLATFORM_VI_NN*/ 2543 2544 //=== VK_KHR_device_group_creation === 2545 2546 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> 2547 enumeratePhysicalDeviceGroupsKHR() const; 2548 2549 # if defined( VK_USE_PLATFORM_IOS_MVK ) 2550 //=== VK_MVK_ios_surface === 2551 2552 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createIOSSurfaceMVK( 2553 VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo, 2554 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2555 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 2556 2557 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 2558 //=== VK_MVK_macos_surface === 2559 2560 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createMacOSSurfaceMVK( 2561 VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo, 2562 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2563 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 2564 2565 //=== VK_EXT_debug_utils === 2566 2567 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT createDebugUtilsMessengerEXT( 2568 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo, 2569 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2570 2571 void submitDebugUtilsMessageEXT( 2572 VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 2573 VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, 2574 const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT; 2575 2576 # if defined( VK_USE_PLATFORM_FUCHSIA ) 2577 //=== VK_FUCHSIA_imagepipe_surface === 2578 2579 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createImagePipeSurfaceFUCHSIA( 2580 VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, 2581 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2582 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 2583 2584 # if defined( VK_USE_PLATFORM_METAL_EXT ) 2585 //=== VK_EXT_metal_surface === 2586 2587 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createMetalSurfaceEXT( 2588 VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo, 2589 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2590 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 2591 2592 //=== VK_EXT_headless_surface === 2593 2594 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createHeadlessSurfaceEXT( 2595 VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo, 2596 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2597 2598 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 2599 //=== VK_EXT_directfb_surface === 2600 2601 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createDirectFBSurfaceEXT( 2602 VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo, 2603 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2604 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 2605 2606 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 2607 //=== VK_QNX_screen_surface === 2608 2609 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createScreenSurfaceQNX( 2610 VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, 2611 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2612 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 2613 2614 private: 2615 VULKAN_HPP_NAMESPACE::Instance m_instance = {}; 2616 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 2617 std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher> m_dispatcher; 2618 }; 2619 2620 class PhysicalDevice 2621 { 2622 public: 2623 using CType = VkPhysicalDevice; 2624 2625 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 2626 VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice; 2627 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 2628 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice; 2629 2630 public: PhysicalDevice(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VkPhysicalDevice physicalDevice)2631 PhysicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 2632 VkPhysicalDevice physicalDevice ) 2633 : m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() ) 2634 {} 2635 PhysicalDevice(std::nullptr_t)2636 PhysicalDevice( std::nullptr_t ) {} 2637 2638 PhysicalDevice() = delete; 2639 PhysicalDevice( PhysicalDevice const & ) = delete; PhysicalDevice(PhysicalDevice && rhs)2640 PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT 2641 : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) 2642 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 2643 {} 2644 PhysicalDevice & operator=( PhysicalDevice const & ) = delete; operator =(PhysicalDevice && rhs)2645 PhysicalDevice & operator =( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT 2646 { 2647 if ( this != &rhs ) 2648 { 2649 m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ); 2650 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 2651 } 2652 return *this; 2653 } 2654 operator *() const2655 VULKAN_HPP_NAMESPACE::PhysicalDevice const & operator*() const VULKAN_HPP_NOEXCEPT 2656 { 2657 return m_physicalDevice; 2658 } 2659 getDispatcher() const2660 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 2661 { 2662 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 2663 return m_dispatcher; 2664 } 2665 2666 //=== VK_VERSION_1_0 === 2667 2668 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT; 2669 2670 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties 2671 getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 2672 2673 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties getImageFormatProperties( 2674 VULKAN_HPP_NAMESPACE::Format format, 2675 VULKAN_HPP_NAMESPACE::ImageType type, 2676 VULKAN_HPP_NAMESPACE::ImageTiling tiling, 2677 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 2678 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 2679 2680 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties() const VULKAN_HPP_NOEXCEPT; 2681 2682 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> 2683 getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT; 2684 2685 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties 2686 getMemoryProperties() const VULKAN_HPP_NOEXCEPT; 2687 2688 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Device createDevice( 2689 VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo, 2690 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 2691 2692 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> enumerateDeviceExtensionProperties( 2693 Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 2694 2695 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateDeviceLayerProperties() const; 2696 2697 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> 2698 getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, 2699 VULKAN_HPP_NAMESPACE::ImageType type, 2700 VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, 2701 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 2702 VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const VULKAN_HPP_NOEXCEPT; 2703 2704 //=== VK_VERSION_1_1 === 2705 2706 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2() const VULKAN_HPP_NOEXCEPT; 2707 2708 template <typename X, typename Y, typename... Z> 2709 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2() const VULKAN_HPP_NOEXCEPT; 2710 2711 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2() const VULKAN_HPP_NOEXCEPT; 2712 2713 template <typename X, typename Y, typename... Z> 2714 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2() const VULKAN_HPP_NOEXCEPT; 2715 2716 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 2717 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 2718 2719 template <typename X, typename Y, typename... Z> 2720 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> 2721 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 2722 2723 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2 2724 getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; 2725 2726 template <typename X, typename Y, typename... Z> 2727 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> 2728 getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; 2729 2730 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> 2731 getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT; 2732 2733 template <typename StructureChain> 2734 VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2() const; 2735 2736 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 2737 getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; 2738 2739 template <typename X, typename Y, typename... Z> 2740 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; 2741 2742 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> 2743 getSparseImageFormatProperties2( 2744 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const VULKAN_HPP_NOEXCEPT; 2745 2746 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties( 2747 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT; 2748 2749 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties( 2750 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT; 2751 2752 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties( 2753 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const 2754 VULKAN_HPP_NOEXCEPT; 2755 2756 //=== VK_KHR_surface === 2757 2758 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 2759 getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 2760 2761 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR 2762 getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 2763 2764 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> 2765 getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 2766 2767 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> getSurfacePresentModesKHR( 2768 VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 2769 2770 //=== VK_KHR_swapchain === 2771 2772 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Rect2D> 2773 getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 2774 2775 //=== VK_KHR_display === 2776 2777 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> getDisplayPropertiesKHR() const; 2778 2779 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> 2780 getDisplayPlanePropertiesKHR() const; 2781 2782 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> 2783 getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const; 2784 2785 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 2786 //=== VK_KHR_xlib_surface === 2787 2788 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR( 2789 uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT; 2790 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 2791 2792 # if defined( VK_USE_PLATFORM_XCB_KHR ) 2793 //=== VK_KHR_xcb_surface === 2794 2795 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getXcbPresentationSupportKHR( 2796 uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT; 2797 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 2798 2799 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 2800 //=== VK_KHR_wayland_surface === 2801 2802 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 2803 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, 2804 struct wl_display & display ) const VULKAN_HPP_NOEXCEPT; 2805 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 2806 2807 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2808 //=== VK_KHR_win32_surface === 2809 2810 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 2811 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT; 2812 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2813 2814 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2815 //=== VK_KHR_video_queue === 2816 2817 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR 2818 getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile ) const; 2819 2820 template <typename X, typename Y, typename... Z> 2821 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> 2822 getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile ) const; 2823 2824 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> getVideoFormatPropertiesKHR( 2825 const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const; 2826 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2827 2828 //=== VK_NV_external_memory_capabilities === 2829 2830 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV getExternalImageFormatPropertiesNV( 2831 VULKAN_HPP_NAMESPACE::Format format, 2832 VULKAN_HPP_NAMESPACE::ImageType type, 2833 VULKAN_HPP_NAMESPACE::ImageTiling tiling, 2834 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 2835 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, 2836 VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType 2837 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 2838 2839 //=== VK_KHR_get_physical_device_properties2 === 2840 2841 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; 2842 2843 template <typename X, typename Y, typename... Z> 2844 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; 2845 2846 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 2847 getProperties2KHR() const VULKAN_HPP_NOEXCEPT; 2848 2849 template <typename X, typename Y, typename... Z> 2850 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2KHR() const VULKAN_HPP_NOEXCEPT; 2851 2852 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 2853 getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 2854 2855 template <typename X, typename Y, typename... Z> 2856 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> 2857 getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 2858 2859 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2 getImageFormatProperties2KHR( 2860 const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; 2861 2862 template <typename X, typename Y, typename... Z> 2863 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageFormatProperties2KHR( 2864 const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; 2865 2866 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> 2867 getQueueFamilyProperties2KHR() const VULKAN_HPP_NOEXCEPT; 2868 2869 template <typename StructureChain> 2870 VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2KHR() const; 2871 2872 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 2873 getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; 2874 2875 template <typename X, typename Y, typename... Z> 2876 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; 2877 2878 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> 2879 getSparseImageFormatProperties2KHR( 2880 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const VULKAN_HPP_NOEXCEPT; 2881 2882 //=== VK_KHR_external_memory_capabilities === 2883 2884 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR( 2885 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT; 2886 2887 //=== VK_KHR_external_semaphore_capabilities === 2888 2889 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( 2890 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const 2891 VULKAN_HPP_NOEXCEPT; 2892 2893 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 2894 //=== VK_EXT_acquire_xlib_display === 2895 2896 void acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; 2897 2898 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getRandROutputDisplayEXT( Display & dpy, 2899 RROutput rrOutput ) const; 2900 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 2901 2902 //=== VK_EXT_display_surface_counter === 2903 2904 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT 2905 getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 2906 2907 //=== VK_KHR_external_fence_capabilities === 2908 2909 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR( 2910 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT; 2911 2912 //=== VK_KHR_performance_query === 2913 2914 VULKAN_HPP_NODISCARD std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>> 2915 enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const; 2916 2917 VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR( 2918 const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const 2919 VULKAN_HPP_NOEXCEPT; 2920 2921 //=== VK_KHR_get_surface_capabilities2 === 2922 2923 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR 2924 getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 2925 2926 template <typename X, typename Y, typename... Z> 2927 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> 2928 getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 2929 2930 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> 2931 getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 2932 2933 //=== VK_KHR_get_display_properties2 === 2934 2935 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> getDisplayProperties2KHR() const; 2936 2937 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> 2938 getDisplayPlaneProperties2KHR() const; 2939 2940 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR 2941 getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const; 2942 2943 //=== VK_EXT_sample_locations === 2944 2945 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT 2946 getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT; 2947 2948 //=== VK_EXT_calibrated_timestamps === 2949 2950 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> getCalibrateableTimeDomainsEXT() const; 2951 2952 //=== VK_KHR_fragment_shading_rate === 2953 2954 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> 2955 getFragmentShadingRatesKHR() const; 2956 2957 //=== VK_EXT_tooling_info === 2958 2959 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT> 2960 getToolPropertiesEXT() const; 2961 2962 //=== VK_NV_cooperative_matrix === 2963 2964 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> 2965 getCooperativeMatrixPropertiesNV() const; 2966 2967 //=== VK_NV_coverage_reduction_mode === 2968 2969 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> 2970 getSupportedFramebufferMixedSamplesCombinationsNV() const; 2971 2972 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2973 //=== VK_EXT_full_screen_exclusive === 2974 2975 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> 2976 getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 2977 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2978 2979 //=== VK_EXT_acquire_drm_display === 2980 2981 void acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; 2982 2983 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getDrmDisplayEXT( int32_t drmFd, 2984 uint32_t connectorId ) const; 2985 2986 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2987 //=== VK_NV_acquire_winrt_display === 2988 2989 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getWinrtDisplayNV( uint32_t deviceRelativeId ) const; 2990 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2991 2992 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 2993 //=== VK_EXT_directfb_surface === 2994 2995 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 2996 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT; 2997 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 2998 2999 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 3000 //=== VK_QNX_screen_surface === 3001 3002 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 3003 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, 3004 struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT; 3005 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 3006 3007 private: 3008 VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; 3009 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 3010 }; 3011 3012 class PhysicalDevices : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> 3013 { 3014 public: PhysicalDevices(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance)3015 PhysicalDevices( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance ) 3016 { 3017 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * dispatcher = 3018 instance.getDispatcher(); 3019 std::vector<VkPhysicalDevice> physicalDevices; 3020 uint32_t physicalDeviceCount; 3021 VULKAN_HPP_NAMESPACE::Result result; 3022 do 3023 { 3024 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkEnumeratePhysicalDevices( 3025 static_cast<VkInstance>( *instance ), &physicalDeviceCount, nullptr ) ); 3026 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceCount ) 3027 { 3028 physicalDevices.resize( physicalDeviceCount ); 3029 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkEnumeratePhysicalDevices( 3030 static_cast<VkInstance>( *instance ), &physicalDeviceCount, physicalDevices.data() ) ); 3031 } 3032 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 3033 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 3034 { 3035 VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); 3036 this->reserve( physicalDeviceCount ); 3037 for ( auto const & physicalDevice : physicalDevices ) 3038 { 3039 this->emplace_back( instance, physicalDevice ); 3040 } 3041 } 3042 else 3043 { 3044 throwResultException( result, "vkEnumeratePhysicalDevices" ); 3045 } 3046 } 3047 3048 PhysicalDevices() = delete; 3049 PhysicalDevices( PhysicalDevices const & ) = delete; 3050 PhysicalDevices( PhysicalDevices && rhs ) = default; 3051 PhysicalDevices & operator=( PhysicalDevices const & ) = delete; 3052 PhysicalDevices & operator=( PhysicalDevices && rhs ) = default; 3053 }; 3054 3055 class Device 3056 { 3057 public: 3058 using CType = VkDevice; 3059 3060 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 3061 VULKAN_HPP_NAMESPACE::ObjectType::eDevice; 3062 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 3063 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice; 3064 3065 public: Device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)3066 Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, 3067 VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo, 3068 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 3069 : m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 3070 { 3071 VULKAN_HPP_NAMESPACE::Result result = 3072 static_cast<VULKAN_HPP_NAMESPACE::Result>( physicalDevice.getDispatcher()->vkCreateDevice( 3073 static_cast<VkPhysicalDevice>( *physicalDevice ), 3074 reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ), 3075 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 3076 reinterpret_cast<VkDevice *>( &m_device ) ) ); 3077 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 3078 { 3079 throwResultException( result, "vkCreateDevice" ); 3080 } 3081 m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher( 3082 physicalDevice.getDispatcher()->vkGetDeviceProcAddr, static_cast<VkDevice>( m_device ) ) ); 3083 } 3084 Device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,VkDevice device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)3085 Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, 3086 VkDevice device, 3087 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 3088 : m_device( device ), m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 3089 { 3090 m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher( 3091 physicalDevice.getDispatcher()->vkGetDeviceProcAddr, static_cast<VkDevice>( m_device ) ) ); 3092 } 3093 Device(std::nullptr_t)3094 Device( std::nullptr_t ) {} 3095 ~Device()3096 ~Device() 3097 { 3098 if ( m_device ) 3099 { 3100 getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ), 3101 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 3102 } 3103 } 3104 3105 Device() = delete; 3106 Device( Device const & ) = delete; Device(Device && rhs)3107 Device( Device && rhs ) VULKAN_HPP_NOEXCEPT 3108 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 3109 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 3110 , m_dispatcher( rhs.m_dispatcher.release() ) 3111 {} 3112 Device & operator=( Device const & ) = delete; operator =(Device && rhs)3113 Device & operator =( Device && rhs ) VULKAN_HPP_NOEXCEPT 3114 { 3115 if ( this != &rhs ) 3116 { 3117 if ( m_device ) 3118 { 3119 getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ), 3120 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 3121 } 3122 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 3123 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 3124 m_dispatcher.reset( rhs.m_dispatcher.release() ); 3125 } 3126 return *this; 3127 } 3128 operator *() const3129 VULKAN_HPP_NAMESPACE::Device const & operator*() const VULKAN_HPP_NOEXCEPT 3130 { 3131 return m_device; 3132 } 3133 getDispatcher() const3134 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 3135 { 3136 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 3137 return &*m_dispatcher; 3138 } 3139 3140 //=== VK_VERSION_1_0 === 3141 3142 VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; 3143 3144 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Queue getQueue( uint32_t queueFamilyIndex, 3145 uint32_t queueIndex ) const; 3146 3147 void waitIdle() const; 3148 3149 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DeviceMemory allocateMemory( 3150 VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo, 3151 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3152 3153 void 3154 flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const; 3155 3156 void invalidateMappedMemoryRanges( 3157 ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const; 3158 3159 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Fence createFence( 3160 VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo, 3161 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3162 3163 void resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const; 3164 3165 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result 3166 waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, 3167 VULKAN_HPP_NAMESPACE::Bool32 waitAll, 3168 uint64_t timeout ) const; 3169 3170 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Semaphore createSemaphore( 3171 VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo, 3172 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3173 3174 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Event createEvent( 3175 VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo, 3176 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3177 3178 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::QueryPool createQueryPool( 3179 VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo, 3180 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3181 3182 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Buffer createBuffer( 3183 VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo, 3184 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3185 3186 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::BufferView createBufferView( 3187 VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo, 3188 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3189 3190 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Image createImage( 3191 VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo, 3192 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3193 3194 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ImageView createImageView( 3195 VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo, 3196 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3197 3198 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ShaderModule createShaderModule( 3199 VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo, 3200 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3201 3202 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PipelineCache createPipelineCache( 3203 VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo, 3204 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3205 3206 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createGraphicsPipelines( 3207 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 3208 pipelineCache, 3209 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, 3210 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3211 3212 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createGraphicsPipeline( 3213 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 3214 pipelineCache, 3215 VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo, 3216 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3217 3218 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createComputePipelines( 3219 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 3220 pipelineCache, 3221 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, 3222 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3223 3224 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createComputePipeline( 3225 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 3226 pipelineCache, 3227 VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo, 3228 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3229 3230 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PipelineLayout createPipelineLayout( 3231 VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo, 3232 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3233 3234 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Sampler createSampler( 3235 VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo, 3236 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3237 3238 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout createDescriptorSetLayout( 3239 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo, 3240 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3241 3242 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorPool createDescriptorPool( 3243 VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo, 3244 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3245 3246 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> 3247 allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const; 3248 3249 void updateDescriptorSets( 3250 ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, 3251 ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT; 3252 3253 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Framebuffer createFramebuffer( 3254 VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo, 3255 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3256 3257 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::RenderPass createRenderPass( 3258 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo, 3259 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3260 3261 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::CommandPool createCommandPool( 3262 VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo, 3263 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3264 3265 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> 3266 allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const; 3267 3268 //=== VK_VERSION_1_1 === 3269 3270 void bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const; 3271 3272 void bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const; 3273 3274 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( 3275 uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT; 3276 3277 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2( 3278 const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3279 3280 template <typename X, typename Y, typename... Z> 3281 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2( 3282 const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3283 3284 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2( 3285 const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3286 3287 template <typename X, typename Y, typename... Z> 3288 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2( 3289 const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3290 3291 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 3292 getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const 3293 VULKAN_HPP_NOEXCEPT; 3294 3295 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Queue 3296 getQueue2( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) const; 3297 3298 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion createSamplerYcbcrConversion( 3299 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 3300 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3301 3302 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate createDescriptorUpdateTemplate( 3303 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 3304 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3305 3306 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( 3307 const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 3308 3309 template <typename X, typename Y, typename... Z> 3310 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( 3311 const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 3312 3313 //=== VK_VERSION_1_2 === 3314 3315 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::RenderPass createRenderPass2( 3316 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 3317 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3318 3319 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result 3320 waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const; 3321 3322 void signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const; 3323 3324 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress 3325 getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3326 3327 VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddress( 3328 const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3329 3330 VULKAN_HPP_NODISCARD uint64_t getMemoryOpaqueCaptureAddress( 3331 const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3332 3333 //=== VK_KHR_swapchain === 3334 3335 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR createSwapchainKHR( 3336 VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 3337 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3338 3339 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR 3340 getGroupPresentCapabilitiesKHR() const; 3341 3342 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR 3343 getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 3344 3345 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> 3346 acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo ) const; 3347 3348 //=== VK_KHR_display_swapchain === 3349 3350 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> createSharedSwapchainsKHR( 3351 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, 3352 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3353 3354 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR createSharedSwapchainKHR( 3355 VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 3356 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3357 3358 //=== VK_EXT_debug_marker === 3359 3360 void debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo ) const; 3361 3362 void debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo ) const; 3363 3364 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 3365 //=== VK_KHR_video_queue === 3366 3367 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR createVideoSessionKHR( 3368 VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, 3369 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3370 3371 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR createVideoSessionParametersKHR( 3372 VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo, 3373 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3374 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 3375 3376 //=== VK_NVX_binary_import === 3377 3378 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX createCuModuleNVX( 3379 VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo, 3380 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3381 3382 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX createCuFunctionNVX( 3383 VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo, 3384 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3385 3386 //=== VK_NVX_image_view_handle === 3387 3388 VULKAN_HPP_NODISCARD uint32_t 3389 getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT; 3390 3391 //=== VK_KHR_device_group === 3392 3393 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( 3394 uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT; 3395 3396 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3397 //=== VK_KHR_external_memory_win32 === 3398 3399 VULKAN_HPP_NODISCARD HANDLE 3400 getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const; 3401 3402 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR 3403 getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, 3404 HANDLE handle ) const; 3405 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3406 3407 //=== VK_KHR_external_memory_fd === 3408 3409 VULKAN_HPP_NODISCARD int getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo ) const; 3410 3411 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR 3412 getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd ) const; 3413 3414 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3415 //=== VK_KHR_external_semaphore_win32 === 3416 3417 void importSemaphoreWin32HandleKHR( 3418 const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const; 3419 3420 VULKAN_HPP_NODISCARD HANDLE getSemaphoreWin32HandleKHR( 3421 const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const; 3422 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3423 3424 //=== VK_KHR_external_semaphore_fd === 3425 3426 void importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const; 3427 3428 VULKAN_HPP_NODISCARD int getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo ) const; 3429 3430 //=== VK_KHR_descriptor_update_template === 3431 3432 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate createDescriptorUpdateTemplateKHR( 3433 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 3434 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3435 3436 void destroyDescriptorUpdateTemplateKHR( 3437 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, 3438 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator 3439 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 3440 3441 //=== VK_EXT_display_control === 3442 3443 void displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, 3444 const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo ) const; 3445 3446 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Fence registerEventEXT( 3447 VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo, 3448 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3449 3450 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Fence registerDisplayEventEXT( 3451 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, 3452 VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo, 3453 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3454 3455 //=== VK_EXT_hdr_metadata === 3456 3457 void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, 3458 ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const 3459 VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; 3460 3461 //=== VK_KHR_create_renderpass2 === 3462 3463 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::RenderPass createRenderPass2KHR( 3464 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 3465 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3466 3467 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3468 //=== VK_KHR_external_fence_win32 === 3469 3470 void importFenceWin32HandleKHR( 3471 const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const; 3472 3473 VULKAN_HPP_NODISCARD HANDLE 3474 getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const; 3475 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3476 3477 //=== VK_KHR_external_fence_fd === 3478 3479 void importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo ) const; 3480 3481 VULKAN_HPP_NODISCARD int getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo ) const; 3482 3483 //=== VK_KHR_performance_query === 3484 3485 void acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info ) const; 3486 3487 void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT; 3488 3489 //=== VK_EXT_debug_utils === 3490 3491 void setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo ) const; 3492 3493 void setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo ) const; 3494 3495 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 3496 //=== VK_ANDROID_external_memory_android_hardware_buffer === 3497 3498 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID 3499 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const; 3500 3501 template <typename X, typename Y, typename... Z> 3502 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> 3503 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const; 3504 3505 VULKAN_HPP_NODISCARD struct AHardwareBuffer * getMemoryAndroidHardwareBufferANDROID( 3506 const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info ) const; 3507 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 3508 3509 //=== VK_KHR_get_memory_requirements2 === 3510 3511 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR( 3512 const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3513 3514 template <typename X, typename Y, typename... Z> 3515 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( 3516 const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3517 3518 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR( 3519 const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3520 3521 template <typename X, typename Y, typename... Z> 3522 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( 3523 const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3524 3525 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 3526 getImageSparseMemoryRequirements2KHR( 3527 const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3528 3529 //=== VK_KHR_acceleration_structure === 3530 3531 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR createAccelerationStructureKHR( 3532 VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo, 3533 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3534 3535 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR( 3536 VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 3537 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 3538 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & 3539 pBuildRangeInfos ) const; 3540 3541 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result 3542 copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 3543 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const; 3544 3545 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureToMemoryKHR( 3546 VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 3547 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const; 3548 3549 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToAccelerationStructureKHR( 3550 VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 3551 const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const; 3552 3553 template <typename T> 3554 VULKAN_HPP_NODISCARD std::vector<T> writeAccelerationStructuresPropertiesKHR( 3555 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 3556 VULKAN_HPP_NAMESPACE::QueryType queryType, 3557 size_t dataSize, 3558 size_t stride ) const; 3559 3560 template <typename T> 3561 VULKAN_HPP_NODISCARD T writeAccelerationStructuresPropertyKHR( 3562 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 3563 VULKAN_HPP_NAMESPACE::QueryType queryType, 3564 size_t stride ) const; 3565 3566 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress getAccelerationStructureAddressKHR( 3567 const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; 3568 3569 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR 3570 getAccelerationStructureCompatibilityKHR( 3571 const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT; 3572 3573 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR 3574 getAccelerationStructureBuildSizesKHR( 3575 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, 3576 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo, 3577 ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const 3578 VULKAN_HPP_NOEXCEPT; 3579 3580 //=== VK_KHR_sampler_ycbcr_conversion === 3581 3582 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion createSamplerYcbcrConversionKHR( 3583 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 3584 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3585 3586 void destroySamplerYcbcrConversionKHR( 3587 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, 3588 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator 3589 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 3590 3591 //=== VK_KHR_bind_memory2 === 3592 3593 void bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const; 3594 3595 void bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const; 3596 3597 //=== VK_EXT_validation_cache === 3598 3599 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT createValidationCacheEXT( 3600 VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo, 3601 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3602 3603 //=== VK_NV_ray_tracing === 3604 3605 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV createAccelerationStructureNV( 3606 VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo, 3607 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3608 3609 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( 3610 const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; 3611 3612 template <typename X, typename Y, typename... Z> 3613 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( 3614 const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; 3615 3616 void bindAccelerationStructureMemoryNV( 3617 ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const; 3618 3619 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createRayTracingPipelinesNV( 3620 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 3621 pipelineCache, 3622 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, 3623 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3624 3625 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createRayTracingPipelineNV( 3626 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 3627 pipelineCache, 3628 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo, 3629 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3630 3631 //=== VK_KHR_maintenance3 === 3632 3633 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( 3634 const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 3635 3636 template <typename X, typename Y, typename... Z> 3637 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( 3638 const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 3639 3640 //=== VK_EXT_external_memory_host === 3641 3642 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT 3643 getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, 3644 const void * pHostPointer ) const; 3645 3646 //=== VK_EXT_calibrated_timestamps === 3647 3648 VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t> getCalibratedTimestampsEXT( 3649 ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos ) const; 3650 3651 VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t> 3652 getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo ) const; 3653 3654 //=== VK_KHR_timeline_semaphore === 3655 3656 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result 3657 waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const; 3658 3659 void signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const; 3660 3661 //=== VK_INTEL_performance_query === 3662 3663 void initializePerformanceApiINTEL( 3664 const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo ) const; 3665 3666 void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT; 3667 3668 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL 3669 acquirePerformanceConfigurationINTEL( 3670 VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const; 3671 3672 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PerformanceValueINTEL 3673 getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const; 3674 3675 //=== VK_EXT_buffer_device_address === 3676 3677 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress 3678 getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3679 3680 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3681 //=== VK_EXT_full_screen_exclusive === 3682 3683 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR getGroupSurfacePresentModes2EXT( 3684 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 3685 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3686 3687 //=== VK_KHR_buffer_device_address === 3688 3689 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress 3690 getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3691 3692 VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddressKHR( 3693 const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3694 3695 VULKAN_HPP_NODISCARD uint64_t getMemoryOpaqueCaptureAddressKHR( 3696 const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3697 3698 //=== VK_KHR_deferred_host_operations === 3699 3700 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR createDeferredOperationKHR( 3701 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3702 3703 //=== VK_KHR_pipeline_executable_properties === 3704 3705 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> 3706 getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo ) const; 3707 3708 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> 3709 getPipelineExecutableStatisticsKHR( 3710 const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const; 3711 3712 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> 3713 getPipelineExecutableInternalRepresentationsKHR( 3714 const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const; 3715 3716 //=== VK_NV_device_generated_commands === 3717 3718 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV( 3719 const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; 3720 3721 template <typename X, typename Y, typename... Z> 3722 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV( 3723 const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; 3724 3725 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV createIndirectCommandsLayoutNV( 3726 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo, 3727 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3728 3729 //=== VK_EXT_private_data === 3730 3731 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlotEXT createPrivateDataSlotEXT( 3732 VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & createInfo, 3733 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3734 3735 void setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 3736 uint64_t objectHandle, 3737 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, 3738 uint64_t data ) const; 3739 3740 VULKAN_HPP_NODISCARD uint64_t 3741 getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 3742 uint64_t objectHandle, 3743 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot ) const VULKAN_HPP_NOEXCEPT; 3744 3745 //=== VK_KHR_ray_tracing_pipeline === 3746 3747 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createRayTracingPipelinesKHR( 3748 VULKAN_HPP_NAMESPACE::Optional< 3749 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 3750 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 3751 pipelineCache, 3752 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, 3753 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3754 3755 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createRayTracingPipelineKHR( 3756 VULKAN_HPP_NAMESPACE::Optional< 3757 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 3758 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 3759 pipelineCache, 3760 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo, 3761 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3762 3763 # if defined( VK_USE_PLATFORM_FUCHSIA ) 3764 //=== VK_FUCHSIA_external_memory === 3765 3766 VULKAN_HPP_NODISCARD zx_handle_t getMemoryZirconHandleFUCHSIA( 3767 const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const; 3768 3769 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA 3770 getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, 3771 zx_handle_t zirconHandle ) const; 3772 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 3773 3774 # if defined( VK_USE_PLATFORM_FUCHSIA ) 3775 //=== VK_FUCHSIA_external_semaphore === 3776 3777 void importSemaphoreZirconHandleFUCHSIA( 3778 const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const; 3779 3780 VULKAN_HPP_NODISCARD zx_handle_t getSemaphoreZirconHandleFUCHSIA( 3781 const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const; 3782 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 3783 3784 # if defined( VK_USE_PLATFORM_FUCHSIA ) 3785 //=== VK_FUCHSIA_buffer_collection === 3786 3787 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA createBufferCollectionFUCHSIA( 3788 VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo, 3789 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3790 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 3791 3792 //=== VK_NV_external_memory_rdma === 3793 3794 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RemoteAddressNV getMemoryRemoteAddressNV( 3795 const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const; 3796 3797 //=== VK_KHR_maintenance4 === 3798 3799 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirementsKHR( 3800 const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info ) const VULKAN_HPP_NOEXCEPT; 3801 3802 template <typename X, typename Y, typename... Z> 3803 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirementsKHR( 3804 const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info ) const VULKAN_HPP_NOEXCEPT; 3805 3806 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirementsKHR( 3807 const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info ) const VULKAN_HPP_NOEXCEPT; 3808 3809 template <typename X, typename Y, typename... Z> 3810 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirementsKHR( 3811 const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info ) const VULKAN_HPP_NOEXCEPT; 3812 3813 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 3814 getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info ) const 3815 VULKAN_HPP_NOEXCEPT; 3816 3817 private: 3818 VULKAN_HPP_NAMESPACE::Device m_device = {}; 3819 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 3820 std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher> m_dispatcher; 3821 }; 3822 3823 class AccelerationStructureKHR 3824 { 3825 public: 3826 using CType = VkAccelerationStructureKHR; 3827 3828 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 3829 VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR; 3830 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 3831 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR; 3832 3833 public: AccelerationStructureKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)3834 AccelerationStructureKHR( 3835 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 3836 VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo, 3837 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 3838 : m_device( *device ) 3839 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 3840 , m_dispatcher( device.getDispatcher() ) 3841 { 3842 VULKAN_HPP_NAMESPACE::Result result = 3843 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateAccelerationStructureKHR( 3844 static_cast<VkDevice>( *device ), 3845 reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ), 3846 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 3847 reinterpret_cast<VkAccelerationStructureKHR *>( &m_accelerationStructure ) ) ); 3848 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 3849 { 3850 throwResultException( result, "vkCreateAccelerationStructureKHR" ); 3851 } 3852 } 3853 AccelerationStructureKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkAccelerationStructureKHR accelerationStructure,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)3854 AccelerationStructureKHR( 3855 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 3856 VkAccelerationStructureKHR accelerationStructure, 3857 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 3858 : m_device( *device ) 3859 , m_accelerationStructure( accelerationStructure ) 3860 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 3861 , m_dispatcher( device.getDispatcher() ) 3862 {} 3863 AccelerationStructureKHR(std::nullptr_t)3864 AccelerationStructureKHR( std::nullptr_t ) {} 3865 ~AccelerationStructureKHR()3866 ~AccelerationStructureKHR() 3867 { 3868 if ( m_accelerationStructure ) 3869 { 3870 getDispatcher()->vkDestroyAccelerationStructureKHR( 3871 static_cast<VkDevice>( m_device ), 3872 static_cast<VkAccelerationStructureKHR>( m_accelerationStructure ), 3873 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 3874 } 3875 } 3876 3877 AccelerationStructureKHR() = delete; 3878 AccelerationStructureKHR( AccelerationStructureKHR const & ) = delete; AccelerationStructureKHR(AccelerationStructureKHR && rhs)3879 AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT 3880 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 3881 , m_accelerationStructure( 3882 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) ) 3883 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 3884 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 3885 {} 3886 AccelerationStructureKHR & operator=( AccelerationStructureKHR const & ) = delete; operator =(AccelerationStructureKHR && rhs)3887 AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT 3888 { 3889 if ( this != &rhs ) 3890 { 3891 if ( m_accelerationStructure ) 3892 { 3893 getDispatcher()->vkDestroyAccelerationStructureKHR( 3894 static_cast<VkDevice>( m_device ), 3895 static_cast<VkAccelerationStructureKHR>( m_accelerationStructure ), 3896 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 3897 } 3898 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 3899 m_accelerationStructure = 3900 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ); 3901 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 3902 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 3903 } 3904 return *this; 3905 } 3906 operator *() const3907 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const VULKAN_HPP_NOEXCEPT 3908 { 3909 return m_accelerationStructure; 3910 } 3911 getDevice() const3912 VULKAN_HPP_NAMESPACE::Device getDevice() const 3913 { 3914 return m_device; 3915 } 3916 getDispatcher() const3917 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 3918 { 3919 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 3920 return m_dispatcher; 3921 } 3922 3923 private: 3924 VULKAN_HPP_NAMESPACE::Device m_device = {}; 3925 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructure = {}; 3926 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 3927 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 3928 }; 3929 3930 class AccelerationStructureNV 3931 { 3932 public: 3933 using CType = VkAccelerationStructureNV; 3934 3935 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 3936 VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV; 3937 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 3938 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV; 3939 3940 public: AccelerationStructureNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)3941 AccelerationStructureNV( 3942 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 3943 VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo, 3944 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 3945 : m_device( *device ) 3946 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 3947 , m_dispatcher( device.getDispatcher() ) 3948 { 3949 VULKAN_HPP_NAMESPACE::Result result = 3950 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateAccelerationStructureNV( 3951 static_cast<VkDevice>( *device ), 3952 reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ), 3953 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 3954 reinterpret_cast<VkAccelerationStructureNV *>( &m_accelerationStructure ) ) ); 3955 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 3956 { 3957 throwResultException( result, "vkCreateAccelerationStructureNV" ); 3958 } 3959 } 3960 AccelerationStructureNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkAccelerationStructureNV accelerationStructure,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)3961 AccelerationStructureNV( 3962 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 3963 VkAccelerationStructureNV accelerationStructure, 3964 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 3965 : m_device( *device ) 3966 , m_accelerationStructure( accelerationStructure ) 3967 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 3968 , m_dispatcher( device.getDispatcher() ) 3969 {} 3970 AccelerationStructureNV(std::nullptr_t)3971 AccelerationStructureNV( std::nullptr_t ) {} 3972 ~AccelerationStructureNV()3973 ~AccelerationStructureNV() 3974 { 3975 if ( m_accelerationStructure ) 3976 { 3977 getDispatcher()->vkDestroyAccelerationStructureNV( 3978 static_cast<VkDevice>( m_device ), 3979 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ), 3980 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 3981 } 3982 } 3983 3984 AccelerationStructureNV() = delete; 3985 AccelerationStructureNV( AccelerationStructureNV const & ) = delete; AccelerationStructureNV(AccelerationStructureNV && rhs)3986 AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT 3987 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 3988 , m_accelerationStructure( 3989 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) ) 3990 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 3991 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 3992 {} 3993 AccelerationStructureNV & operator=( AccelerationStructureNV const & ) = delete; operator =(AccelerationStructureNV && rhs)3994 AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT 3995 { 3996 if ( this != &rhs ) 3997 { 3998 if ( m_accelerationStructure ) 3999 { 4000 getDispatcher()->vkDestroyAccelerationStructureNV( 4001 static_cast<VkDevice>( m_device ), 4002 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ), 4003 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4004 } 4005 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 4006 m_accelerationStructure = 4007 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ); 4008 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 4009 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 4010 } 4011 return *this; 4012 } 4013 operator *() const4014 VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & operator*() const VULKAN_HPP_NOEXCEPT 4015 { 4016 return m_accelerationStructure; 4017 } 4018 getDevice() const4019 VULKAN_HPP_NAMESPACE::Device getDevice() const 4020 { 4021 return m_device; 4022 } 4023 getDispatcher() const4024 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 4025 { 4026 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 4027 return m_dispatcher; 4028 } 4029 4030 //=== VK_NV_ray_tracing === 4031 4032 template <typename T> 4033 VULKAN_HPP_NODISCARD std::vector<T> getHandle( size_t dataSize ) const; 4034 4035 template <typename T> 4036 VULKAN_HPP_NODISCARD T getHandle() const; 4037 4038 private: 4039 VULKAN_HPP_NAMESPACE::Device m_device = {}; 4040 VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructure = {}; 4041 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 4042 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 4043 }; 4044 4045 class Buffer 4046 { 4047 public: 4048 using CType = VkBuffer; 4049 4050 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 4051 VULKAN_HPP_NAMESPACE::ObjectType::eBuffer; 4052 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 4053 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer; 4054 4055 public: Buffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4056 Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4057 VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo, 4058 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4059 : m_device( *device ) 4060 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4061 , m_dispatcher( device.getDispatcher() ) 4062 { 4063 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 4064 device.getDispatcher()->vkCreateBuffer( static_cast<VkDevice>( *device ), 4065 reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ), 4066 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 4067 reinterpret_cast<VkBuffer *>( &m_buffer ) ) ); 4068 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 4069 { 4070 throwResultException( result, "vkCreateBuffer" ); 4071 } 4072 } 4073 Buffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkBuffer buffer,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4074 Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4075 VkBuffer buffer, 4076 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4077 : m_device( *device ) 4078 , m_buffer( buffer ) 4079 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4080 , m_dispatcher( device.getDispatcher() ) 4081 {} 4082 Buffer(std::nullptr_t)4083 Buffer( std::nullptr_t ) {} 4084 ~Buffer()4085 ~Buffer() 4086 { 4087 if ( m_buffer ) 4088 { 4089 getDispatcher()->vkDestroyBuffer( static_cast<VkDevice>( m_device ), 4090 static_cast<VkBuffer>( m_buffer ), 4091 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4092 } 4093 } 4094 4095 Buffer() = delete; 4096 Buffer( Buffer const & ) = delete; Buffer(Buffer && rhs)4097 Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT 4098 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 4099 , m_buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} ) ) 4100 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 4101 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 4102 {} 4103 Buffer & operator=( Buffer const & ) = delete; operator =(Buffer && rhs)4104 Buffer & operator =( Buffer && rhs ) VULKAN_HPP_NOEXCEPT 4105 { 4106 if ( this != &rhs ) 4107 { 4108 if ( m_buffer ) 4109 { 4110 getDispatcher()->vkDestroyBuffer( static_cast<VkDevice>( m_device ), 4111 static_cast<VkBuffer>( m_buffer ), 4112 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4113 } 4114 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 4115 m_buffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} ); 4116 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 4117 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 4118 } 4119 return *this; 4120 } 4121 operator *() const4122 VULKAN_HPP_NAMESPACE::Buffer const & operator*() const VULKAN_HPP_NOEXCEPT 4123 { 4124 return m_buffer; 4125 } 4126 getDevice() const4127 VULKAN_HPP_NAMESPACE::Device getDevice() const 4128 { 4129 return m_device; 4130 } 4131 getDispatcher() const4132 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 4133 { 4134 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 4135 return m_dispatcher; 4136 } 4137 4138 //=== VK_VERSION_1_0 === 4139 4140 void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const; 4141 4142 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; 4143 4144 private: 4145 VULKAN_HPP_NAMESPACE::Device m_device = {}; 4146 VULKAN_HPP_NAMESPACE::Buffer m_buffer = {}; 4147 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 4148 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 4149 }; 4150 4151 # if defined( VK_USE_PLATFORM_FUCHSIA ) 4152 class BufferCollectionFUCHSIA 4153 { 4154 public: 4155 using CType = VkBufferCollectionFUCHSIA; 4156 4157 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 4158 VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA; 4159 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 4160 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA; 4161 4162 public: BufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4163 BufferCollectionFUCHSIA( 4164 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4165 VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo, 4166 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4167 : m_device( *device ) 4168 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4169 , m_dispatcher( device.getDispatcher() ) 4170 { 4171 VULKAN_HPP_NAMESPACE::Result result = 4172 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateBufferCollectionFUCHSIA( 4173 static_cast<VkDevice>( *device ), 4174 reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( &createInfo ), 4175 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 4176 reinterpret_cast<VkBufferCollectionFUCHSIA *>( &m_collection ) ) ); 4177 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 4178 { 4179 throwResultException( result, "vkCreateBufferCollectionFUCHSIA" ); 4180 } 4181 } 4182 BufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkBufferCollectionFUCHSIA collection,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4183 BufferCollectionFUCHSIA( 4184 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4185 VkBufferCollectionFUCHSIA collection, 4186 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4187 : m_device( *device ) 4188 , m_collection( collection ) 4189 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4190 , m_dispatcher( device.getDispatcher() ) 4191 {} 4192 BufferCollectionFUCHSIA(std::nullptr_t)4193 BufferCollectionFUCHSIA( std::nullptr_t ) {} 4194 ~BufferCollectionFUCHSIA()4195 ~BufferCollectionFUCHSIA() 4196 { 4197 if ( m_collection ) 4198 { 4199 getDispatcher()->vkDestroyBufferCollectionFUCHSIA( 4200 static_cast<VkDevice>( m_device ), 4201 static_cast<VkBufferCollectionFUCHSIA>( m_collection ), 4202 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4203 } 4204 } 4205 4206 BufferCollectionFUCHSIA() = delete; 4207 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & ) = delete; BufferCollectionFUCHSIA(BufferCollectionFUCHSIA && rhs)4208 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT 4209 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 4210 , m_collection( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_collection, {} ) ) 4211 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 4212 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 4213 {} 4214 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete; operator =(BufferCollectionFUCHSIA && rhs)4215 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT 4216 { 4217 if ( this != &rhs ) 4218 { 4219 if ( m_collection ) 4220 { 4221 getDispatcher()->vkDestroyBufferCollectionFUCHSIA( 4222 static_cast<VkDevice>( m_device ), 4223 static_cast<VkBufferCollectionFUCHSIA>( m_collection ), 4224 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4225 } 4226 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 4227 m_collection = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_collection, {} ); 4228 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 4229 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 4230 } 4231 return *this; 4232 } 4233 operator *() const4234 VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & operator*() const VULKAN_HPP_NOEXCEPT 4235 { 4236 return m_collection; 4237 } 4238 getDevice() const4239 VULKAN_HPP_NAMESPACE::Device getDevice() const 4240 { 4241 return m_device; 4242 } 4243 getDispatcher() const4244 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 4245 { 4246 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 4247 return m_dispatcher; 4248 } 4249 4250 //=== VK_FUCHSIA_buffer_collection === 4251 4252 void setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const; 4253 4254 void 4255 setBufferConstraints( const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const; 4256 4257 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties() const; 4258 4259 private: 4260 VULKAN_HPP_NAMESPACE::Device m_device = {}; 4261 VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_collection = {}; 4262 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 4263 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 4264 }; 4265 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 4266 4267 class BufferView 4268 { 4269 public: 4270 using CType = VkBufferView; 4271 4272 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 4273 VULKAN_HPP_NAMESPACE::ObjectType::eBufferView; 4274 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 4275 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView; 4276 4277 public: BufferView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4278 BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4279 VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo, 4280 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4281 : m_device( *device ) 4282 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4283 , m_dispatcher( device.getDispatcher() ) 4284 { 4285 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 4286 device.getDispatcher()->vkCreateBufferView( static_cast<VkDevice>( *device ), 4287 reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ), 4288 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 4289 reinterpret_cast<VkBufferView *>( &m_bufferView ) ) ); 4290 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 4291 { 4292 throwResultException( result, "vkCreateBufferView" ); 4293 } 4294 } 4295 BufferView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkBufferView bufferView,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4296 BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4297 VkBufferView bufferView, 4298 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4299 : m_device( *device ) 4300 , m_bufferView( bufferView ) 4301 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4302 , m_dispatcher( device.getDispatcher() ) 4303 {} 4304 BufferView(std::nullptr_t)4305 BufferView( std::nullptr_t ) {} 4306 ~BufferView()4307 ~BufferView() 4308 { 4309 if ( m_bufferView ) 4310 { 4311 getDispatcher()->vkDestroyBufferView( static_cast<VkDevice>( m_device ), 4312 static_cast<VkBufferView>( m_bufferView ), 4313 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4314 } 4315 } 4316 4317 BufferView() = delete; 4318 BufferView( BufferView const & ) = delete; BufferView(BufferView && rhs)4319 BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT 4320 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 4321 , m_bufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} ) ) 4322 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 4323 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 4324 {} 4325 BufferView & operator=( BufferView const & ) = delete; operator =(BufferView && rhs)4326 BufferView & operator =( BufferView && rhs ) VULKAN_HPP_NOEXCEPT 4327 { 4328 if ( this != &rhs ) 4329 { 4330 if ( m_bufferView ) 4331 { 4332 getDispatcher()->vkDestroyBufferView( static_cast<VkDevice>( m_device ), 4333 static_cast<VkBufferView>( m_bufferView ), 4334 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4335 } 4336 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 4337 m_bufferView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} ); 4338 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 4339 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 4340 } 4341 return *this; 4342 } 4343 operator *() const4344 VULKAN_HPP_NAMESPACE::BufferView const & operator*() const VULKAN_HPP_NOEXCEPT 4345 { 4346 return m_bufferView; 4347 } 4348 getDevice() const4349 VULKAN_HPP_NAMESPACE::Device getDevice() const 4350 { 4351 return m_device; 4352 } 4353 getDispatcher() const4354 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 4355 { 4356 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 4357 return m_dispatcher; 4358 } 4359 4360 private: 4361 VULKAN_HPP_NAMESPACE::Device m_device = {}; 4362 VULKAN_HPP_NAMESPACE::BufferView m_bufferView = {}; 4363 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 4364 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 4365 }; 4366 4367 class CommandPool 4368 { 4369 public: 4370 using CType = VkCommandPool; 4371 4372 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 4373 VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool; 4374 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 4375 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool; 4376 4377 public: CommandPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4378 CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4379 VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo, 4380 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4381 : m_device( *device ) 4382 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4383 , m_dispatcher( device.getDispatcher() ) 4384 { 4385 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 4386 device.getDispatcher()->vkCreateCommandPool( static_cast<VkDevice>( *device ), 4387 reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ), 4388 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 4389 reinterpret_cast<VkCommandPool *>( &m_commandPool ) ) ); 4390 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 4391 { 4392 throwResultException( result, "vkCreateCommandPool" ); 4393 } 4394 } 4395 CommandPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCommandPool commandPool,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4396 CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4397 VkCommandPool commandPool, 4398 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4399 : m_device( *device ) 4400 , m_commandPool( commandPool ) 4401 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4402 , m_dispatcher( device.getDispatcher() ) 4403 {} 4404 CommandPool(std::nullptr_t)4405 CommandPool( std::nullptr_t ) {} 4406 ~CommandPool()4407 ~CommandPool() 4408 { 4409 if ( m_commandPool ) 4410 { 4411 getDispatcher()->vkDestroyCommandPool( static_cast<VkDevice>( m_device ), 4412 static_cast<VkCommandPool>( m_commandPool ), 4413 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4414 } 4415 } 4416 4417 CommandPool() = delete; 4418 CommandPool( CommandPool const & ) = delete; CommandPool(CommandPool && rhs)4419 CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT 4420 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 4421 , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) 4422 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 4423 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 4424 {} 4425 CommandPool & operator=( CommandPool const & ) = delete; operator =(CommandPool && rhs)4426 CommandPool & operator =( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT 4427 { 4428 if ( this != &rhs ) 4429 { 4430 if ( m_commandPool ) 4431 { 4432 getDispatcher()->vkDestroyCommandPool( static_cast<VkDevice>( m_device ), 4433 static_cast<VkCommandPool>( m_commandPool ), 4434 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4435 } 4436 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 4437 m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ); 4438 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 4439 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 4440 } 4441 return *this; 4442 } 4443 operator *() const4444 VULKAN_HPP_NAMESPACE::CommandPool const & operator*() const VULKAN_HPP_NOEXCEPT 4445 { 4446 return m_commandPool; 4447 } 4448 getDevice() const4449 VULKAN_HPP_NAMESPACE::Device getDevice() const 4450 { 4451 return m_device; 4452 } 4453 getDispatcher() const4454 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 4455 { 4456 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 4457 return m_dispatcher; 4458 } 4459 4460 //=== VK_VERSION_1_0 === 4461 4462 void reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 4463 4464 //=== VK_VERSION_1_1 === 4465 4466 void trim( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const 4467 VULKAN_HPP_NOEXCEPT; 4468 4469 //=== VK_KHR_maintenance1 === 4470 4471 void trimKHR( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const 4472 VULKAN_HPP_NOEXCEPT; 4473 4474 private: 4475 VULKAN_HPP_NAMESPACE::Device m_device = {}; 4476 VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; 4477 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 4478 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 4479 }; 4480 4481 class CommandBuffer 4482 { 4483 public: 4484 using CType = VkCommandBuffer; 4485 4486 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 4487 VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer; 4488 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 4489 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer; 4490 4491 public: CommandBuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCommandBuffer commandBuffer,VkCommandPool commandPool)4492 CommandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4493 VkCommandBuffer commandBuffer, 4494 VkCommandPool commandPool ) 4495 : m_device( *device ) 4496 , m_commandPool( commandPool ) 4497 , m_commandBuffer( commandBuffer ) 4498 , m_dispatcher( device.getDispatcher() ) 4499 {} 4500 CommandBuffer(std::nullptr_t)4501 CommandBuffer( std::nullptr_t ) {} 4502 ~CommandBuffer()4503 ~CommandBuffer() 4504 { 4505 if ( m_commandBuffer ) 4506 { 4507 getDispatcher()->vkFreeCommandBuffers( static_cast<VkDevice>( m_device ), 4508 static_cast<VkCommandPool>( m_commandPool ), 4509 1, 4510 reinterpret_cast<VkCommandBuffer const *>( &m_commandBuffer ) ); 4511 } 4512 } 4513 4514 CommandBuffer() = delete; 4515 CommandBuffer( CommandBuffer const & ) = delete; CommandBuffer(CommandBuffer && rhs)4516 CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT 4517 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 4518 , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) 4519 , m_commandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) ) 4520 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 4521 {} 4522 CommandBuffer & operator=( CommandBuffer const & ) = delete; operator =(CommandBuffer && rhs)4523 CommandBuffer & operator =( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT 4524 { 4525 if ( this != &rhs ) 4526 { 4527 if ( m_commandBuffer ) 4528 { 4529 getDispatcher()->vkFreeCommandBuffers( static_cast<VkDevice>( m_device ), 4530 static_cast<VkCommandPool>( m_commandPool ), 4531 1, 4532 reinterpret_cast<VkCommandBuffer const *>( &m_commandBuffer ) ); 4533 } 4534 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 4535 m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ); 4536 m_commandBuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} ); 4537 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 4538 } 4539 return *this; 4540 } 4541 operator *() const4542 VULKAN_HPP_NAMESPACE::CommandBuffer const & operator*() const VULKAN_HPP_NOEXCEPT 4543 { 4544 return m_commandBuffer; 4545 } 4546 getDevice() const4547 VULKAN_HPP_NAMESPACE::Device getDevice() const 4548 { 4549 return m_device; 4550 } 4551 getDispatcher() const4552 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 4553 { 4554 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 4555 return m_dispatcher; 4556 } 4557 4558 //=== VK_VERSION_1_0 === 4559 4560 void begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const; 4561 4562 void end() const; 4563 4564 void reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 4565 4566 void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 4567 VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT; 4568 4569 void setViewport( uint32_t firstViewport, 4570 ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT; 4571 4572 void setScissor( uint32_t firstScissor, 4573 ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT; 4574 4575 void setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT; 4576 4577 void setDepthBias( float depthBiasConstantFactor, 4578 float depthBiasClamp, 4579 float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT; 4580 4581 void setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT; 4582 4583 void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT; 4584 4585 void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 4586 uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT; 4587 4588 void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 4589 uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT; 4590 4591 void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 4592 uint32_t reference ) const VULKAN_HPP_NOEXCEPT; 4593 4594 void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 4595 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 4596 uint32_t firstSet, 4597 ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, 4598 ArrayProxy<const uint32_t> const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT; 4599 4600 void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, 4601 VULKAN_HPP_NAMESPACE::DeviceSize offset, 4602 VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT; 4603 4604 void bindVertexBuffers( uint32_t firstBinding, 4605 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 4606 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const 4607 VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; 4608 4609 void draw( uint32_t vertexCount, 4610 uint32_t instanceCount, 4611 uint32_t firstVertex, 4612 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; 4613 4614 void drawIndexed( uint32_t indexCount, 4615 uint32_t instanceCount, 4616 uint32_t firstIndex, 4617 int32_t vertexOffset, 4618 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; 4619 4620 void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 4621 VULKAN_HPP_NAMESPACE::DeviceSize offset, 4622 uint32_t drawCount, 4623 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 4624 4625 void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 4626 VULKAN_HPP_NAMESPACE::DeviceSize offset, 4627 uint32_t drawCount, 4628 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 4629 4630 void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; 4631 4632 void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 4633 VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT; 4634 4635 void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, 4636 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 4637 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT; 4638 4639 void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, 4640 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 4641 VULKAN_HPP_NAMESPACE::Image dstImage, 4642 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 4643 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT; 4644 4645 void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, 4646 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 4647 VULKAN_HPP_NAMESPACE::Image dstImage, 4648 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 4649 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions, 4650 VULKAN_HPP_NAMESPACE::Filter filter ) const VULKAN_HPP_NOEXCEPT; 4651 4652 void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, 4653 VULKAN_HPP_NAMESPACE::Image dstImage, 4654 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 4655 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const 4656 VULKAN_HPP_NOEXCEPT; 4657 4658 void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, 4659 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 4660 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 4661 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const 4662 VULKAN_HPP_NOEXCEPT; 4663 4664 template <typename T> 4665 void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 4666 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 4667 ArrayProxy<const T> const & data ) const VULKAN_HPP_NOEXCEPT; 4668 4669 void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 4670 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 4671 VULKAN_HPP_NAMESPACE::DeviceSize size, 4672 uint32_t data ) const VULKAN_HPP_NOEXCEPT; 4673 4674 void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, 4675 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, 4676 const VULKAN_HPP_NAMESPACE::ClearColorValue & color, 4677 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const 4678 VULKAN_HPP_NOEXCEPT; 4679 4680 void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, 4681 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, 4682 const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil, 4683 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const 4684 VULKAN_HPP_NOEXCEPT; 4685 4686 void 4687 clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments, 4688 ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects ) const VULKAN_HPP_NOEXCEPT; 4689 4690 void 4691 resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, 4692 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 4693 VULKAN_HPP_NAMESPACE::Image dstImage, 4694 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 4695 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT; 4696 4697 void setEvent( VULKAN_HPP_NAMESPACE::Event event, 4698 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask 4699 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 4700 4701 void resetEvent( VULKAN_HPP_NAMESPACE::Event event, 4702 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask 4703 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 4704 4705 void waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 4706 VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, 4707 VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, 4708 ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, 4709 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, 4710 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const 4711 VULKAN_HPP_NOEXCEPT; 4712 4713 void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, 4714 VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, 4715 VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, 4716 ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, 4717 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, 4718 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) 4719 const VULKAN_HPP_NOEXCEPT; 4720 4721 void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 4722 uint32_t query, 4723 VULKAN_HPP_NAMESPACE::QueryControlFlags flags 4724 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 4725 4726 void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; 4727 4728 void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 4729 uint32_t firstQuery, 4730 uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; 4731 4732 void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, 4733 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 4734 uint32_t query ) const VULKAN_HPP_NOEXCEPT; 4735 4736 void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 4737 uint32_t firstQuery, 4738 uint32_t queryCount, 4739 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 4740 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 4741 VULKAN_HPP_NAMESPACE::DeviceSize stride, 4742 VULKAN_HPP_NAMESPACE::QueryResultFlags flags 4743 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 4744 4745 template <typename T> 4746 void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, 4747 VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, 4748 uint32_t offset, 4749 ArrayProxy<const T> const & values ) const VULKAN_HPP_NOEXCEPT; 4750 4751 void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 4752 VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT; 4753 4754 void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT; 4755 4756 void endRenderPass() const VULKAN_HPP_NOEXCEPT; 4757 4758 void executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const 4759 VULKAN_HPP_NOEXCEPT; 4760 4761 //=== VK_VERSION_1_1 === 4762 4763 void setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT; 4764 4765 void dispatchBase( uint32_t baseGroupX, 4766 uint32_t baseGroupY, 4767 uint32_t baseGroupZ, 4768 uint32_t groupCountX, 4769 uint32_t groupCountY, 4770 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; 4771 4772 //=== VK_VERSION_1_2 === 4773 4774 void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, 4775 VULKAN_HPP_NAMESPACE::DeviceSize offset, 4776 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 4777 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 4778 uint32_t maxDrawCount, 4779 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 4780 4781 void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, 4782 VULKAN_HPP_NAMESPACE::DeviceSize offset, 4783 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 4784 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 4785 uint32_t maxDrawCount, 4786 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 4787 4788 void 4789 beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 4790 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT; 4791 4792 void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, 4793 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; 4794 4795 void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; 4796 4797 //=== VK_EXT_debug_marker === 4798 4799 void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const 4800 VULKAN_HPP_NOEXCEPT; 4801 4802 void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT; 4803 4804 void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const 4805 VULKAN_HPP_NOEXCEPT; 4806 4807 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4808 //=== VK_KHR_video_queue === 4809 4810 void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo ) const 4811 VULKAN_HPP_NOEXCEPT; 4812 4813 void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo ) const 4814 VULKAN_HPP_NOEXCEPT; 4815 4816 void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo ) const 4817 VULKAN_HPP_NOEXCEPT; 4818 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4819 4820 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4821 //=== VK_KHR_video_decode_queue === 4822 4823 void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & frameInfo ) const VULKAN_HPP_NOEXCEPT; 4824 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4825 4826 //=== VK_EXT_transform_feedback === 4827 4828 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, 4829 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 4830 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 4831 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes 4832 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const 4833 VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; 4834 4835 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, 4836 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, 4837 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets 4838 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const 4839 VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; 4840 4841 void endTransformFeedbackEXT( uint32_t firstCounterBuffer, 4842 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, 4843 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets 4844 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const 4845 VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; 4846 4847 void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 4848 uint32_t query, 4849 VULKAN_HPP_NAMESPACE::QueryControlFlags flags, 4850 uint32_t index ) const VULKAN_HPP_NOEXCEPT; 4851 4852 void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 4853 uint32_t query, 4854 uint32_t index ) const VULKAN_HPP_NOEXCEPT; 4855 4856 void drawIndirectByteCountEXT( uint32_t instanceCount, 4857 uint32_t firstInstance, 4858 VULKAN_HPP_NAMESPACE::Buffer counterBuffer, 4859 VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, 4860 uint32_t counterOffset, 4861 uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT; 4862 4863 //=== VK_NVX_binary_import === 4864 4865 void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT; 4866 4867 //=== VK_AMD_draw_indirect_count === 4868 4869 void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, 4870 VULKAN_HPP_NAMESPACE::DeviceSize offset, 4871 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 4872 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 4873 uint32_t maxDrawCount, 4874 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 4875 4876 void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, 4877 VULKAN_HPP_NAMESPACE::DeviceSize offset, 4878 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 4879 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 4880 uint32_t maxDrawCount, 4881 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 4882 4883 //=== VK_KHR_dynamic_rendering === 4884 4885 void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfoKHR & renderingInfo ) const VULKAN_HPP_NOEXCEPT; 4886 4887 void endRenderingKHR() const VULKAN_HPP_NOEXCEPT; 4888 4889 //=== VK_KHR_device_group === 4890 4891 void setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT; 4892 4893 void dispatchBaseKHR( uint32_t baseGroupX, 4894 uint32_t baseGroupY, 4895 uint32_t baseGroupZ, 4896 uint32_t groupCountX, 4897 uint32_t groupCountY, 4898 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; 4899 4900 //=== VK_KHR_push_descriptor === 4901 4902 void pushDescriptorSetKHR( 4903 VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 4904 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 4905 uint32_t set, 4906 ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT; 4907 4908 void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 4909 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 4910 uint32_t set, 4911 const void * pData ) const VULKAN_HPP_NOEXCEPT; 4912 4913 //=== VK_EXT_conditional_rendering === 4914 4915 void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & 4916 conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT; 4917 4918 void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT; 4919 4920 //=== VK_NV_clip_space_w_scaling === 4921 4922 void setViewportWScalingNV( uint32_t firstViewport, 4923 ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) 4924 const VULKAN_HPP_NOEXCEPT; 4925 4926 //=== VK_EXT_discard_rectangles === 4927 4928 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, 4929 ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const 4930 VULKAN_HPP_NOEXCEPT; 4931 4932 //=== VK_KHR_create_renderpass2 === 4933 4934 void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 4935 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const 4936 VULKAN_HPP_NOEXCEPT; 4937 4938 void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, 4939 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; 4940 4941 void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; 4942 4943 //=== VK_EXT_debug_utils === 4944 4945 void 4946 beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; 4947 4948 void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; 4949 4950 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const 4951 VULKAN_HPP_NOEXCEPT; 4952 4953 //=== VK_EXT_sample_locations === 4954 4955 void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo ) const 4956 VULKAN_HPP_NOEXCEPT; 4957 4958 //=== VK_KHR_acceleration_structure === 4959 4960 void buildAccelerationStructuresKHR( 4961 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 4962 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & 4963 pBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; 4964 4965 void buildAccelerationStructuresIndirectKHR( 4966 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 4967 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses, 4968 ArrayProxy<const uint32_t> const & indirectStrides, 4969 ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; 4970 4971 void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const 4972 VULKAN_HPP_NOEXCEPT; 4973 4974 void copyAccelerationStructureToMemoryKHR( 4975 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; 4976 4977 void copyMemoryToAccelerationStructureKHR( 4978 const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; 4979 4980 void writeAccelerationStructuresPropertiesKHR( 4981 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 4982 VULKAN_HPP_NAMESPACE::QueryType queryType, 4983 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 4984 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; 4985 4986 //=== VK_NV_shading_rate_image === 4987 4988 void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, 4989 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT; 4990 4991 void setViewportShadingRatePaletteNV( uint32_t firstViewport, 4992 ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & 4993 shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT; 4994 4995 void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, 4996 ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & 4997 customSampleOrders ) const VULKAN_HPP_NOEXCEPT; 4998 4999 //=== VK_NV_ray_tracing === 5000 5001 void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info, 5002 VULKAN_HPP_NAMESPACE::Buffer instanceData, 5003 VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, 5004 VULKAN_HPP_NAMESPACE::Bool32 update, 5005 VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, 5006 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, 5007 VULKAN_HPP_NAMESPACE::Buffer scratch, 5008 VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT; 5009 5010 void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, 5011 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, 5012 VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode ) const 5013 VULKAN_HPP_NOEXCEPT; 5014 5015 void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, 5016 VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, 5017 VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, 5018 VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, 5019 VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, 5020 VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, 5021 VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, 5022 VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, 5023 VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, 5024 VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, 5025 VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, 5026 uint32_t width, 5027 uint32_t height, 5028 uint32_t depth ) const VULKAN_HPP_NOEXCEPT; 5029 5030 void writeAccelerationStructuresPropertiesNV( 5031 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures, 5032 VULKAN_HPP_NAMESPACE::QueryType queryType, 5033 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 5034 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; 5035 5036 //=== VK_KHR_draw_indirect_count === 5037 5038 void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 5039 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5040 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 5041 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 5042 uint32_t maxDrawCount, 5043 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5044 5045 void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 5046 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5047 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 5048 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 5049 uint32_t maxDrawCount, 5050 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5051 5052 //=== VK_AMD_buffer_marker === 5053 5054 void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, 5055 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 5056 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 5057 uint32_t marker ) const VULKAN_HPP_NOEXCEPT; 5058 5059 //=== VK_NV_mesh_shader === 5060 5061 void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT; 5062 5063 void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, 5064 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5065 uint32_t drawCount, 5066 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5067 5068 void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, 5069 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5070 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 5071 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 5072 uint32_t maxDrawCount, 5073 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5074 5075 //=== VK_NV_scissor_exclusive === 5076 5077 void setExclusiveScissorNV( uint32_t firstExclusiveScissor, 5078 ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const 5079 VULKAN_HPP_NOEXCEPT; 5080 5081 //=== VK_NV_device_diagnostic_checkpoints === 5082 5083 void setCheckpointNV( const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT; 5084 5085 //=== VK_INTEL_performance_query === 5086 5087 void setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo ) const; 5088 5089 void setPerformanceStreamMarkerINTEL( 5090 const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo ) const; 5091 5092 void setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo ) const; 5093 5094 //=== VK_KHR_fragment_shading_rate === 5095 5096 void setFragmentShadingRateKHR( 5097 const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize, 5098 const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; 5099 5100 //=== VK_EXT_line_rasterization === 5101 5102 void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; 5103 5104 //=== VK_EXT_extended_dynamic_state === 5105 5106 void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const 5107 VULKAN_HPP_NOEXCEPT; 5108 5109 void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT; 5110 5111 void 5112 setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT; 5113 5114 void setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const 5115 VULKAN_HPP_NOEXCEPT; 5116 5117 void setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const 5118 VULKAN_HPP_NOEXCEPT; 5119 5120 void bindVertexBuffers2EXT( 5121 uint32_t firstBinding, 5122 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 5123 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 5124 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, 5125 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides 5126 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; 5127 5128 void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT; 5129 5130 void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT; 5131 5132 void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT; 5133 5134 void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT; 5135 5136 void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT; 5137 5138 void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 5139 VULKAN_HPP_NAMESPACE::StencilOp failOp, 5140 VULKAN_HPP_NAMESPACE::StencilOp passOp, 5141 VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, 5142 VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT; 5143 5144 //=== VK_NV_device_generated_commands === 5145 5146 void preprocessGeneratedCommandsNV( 5147 const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; 5148 5149 void executeGeneratedCommandsNV( 5150 VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, 5151 const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; 5152 5153 void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 5154 VULKAN_HPP_NAMESPACE::Pipeline pipeline, 5155 uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT; 5156 5157 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 5158 //=== VK_KHR_video_encode_queue === 5159 5160 void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT; 5161 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 5162 5163 //=== VK_KHR_synchronization2 === 5164 5165 void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, 5166 const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; 5167 5168 void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, 5169 VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask 5170 VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5171 5172 void waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 5173 ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos ) const 5174 VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; 5175 5176 void 5177 pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; 5178 5179 void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage, 5180 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 5181 uint32_t query ) const VULKAN_HPP_NOEXCEPT; 5182 5183 void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage, 5184 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 5185 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 5186 uint32_t marker ) const VULKAN_HPP_NOEXCEPT; 5187 5188 //=== VK_NV_fragment_shading_rate_enums === 5189 5190 void setFragmentShadingRateEnumNV( 5191 VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, 5192 const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; 5193 5194 //=== VK_KHR_copy_commands2 === 5195 5196 void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT; 5197 5198 void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR & copyImageInfo ) const VULKAN_HPP_NOEXCEPT; 5199 5200 void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR & copyBufferToImageInfo ) const 5201 VULKAN_HPP_NOEXCEPT; 5202 5203 void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR & copyImageToBufferInfo ) const 5204 VULKAN_HPP_NOEXCEPT; 5205 5206 void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR & blitImageInfo ) const VULKAN_HPP_NOEXCEPT; 5207 5208 void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR & resolveImageInfo ) const 5209 VULKAN_HPP_NOEXCEPT; 5210 5211 //=== VK_KHR_ray_tracing_pipeline === 5212 5213 void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, 5214 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, 5215 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, 5216 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, 5217 uint32_t width, 5218 uint32_t height, 5219 uint32_t depth ) const VULKAN_HPP_NOEXCEPT; 5220 5221 void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, 5222 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, 5223 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, 5224 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, 5225 VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT; 5226 5227 void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT; 5228 5229 //=== VK_EXT_vertex_input_dynamic_state === 5230 5231 void setVertexInputEXT( 5232 ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions, 5233 ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & 5234 vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT; 5235 5236 //=== VK_HUAWEI_subpass_shading === 5237 5238 void subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT; 5239 5240 //=== VK_HUAWEI_invocation_mask === 5241 5242 void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, 5243 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT; 5244 5245 //=== VK_EXT_extended_dynamic_state2 === 5246 5247 void setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT; 5248 5249 void 5250 setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT; 5251 5252 void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT; 5253 5254 void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT; 5255 5256 void 5257 setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT; 5258 5259 //=== VK_EXT_color_write_enable === 5260 5261 void setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const 5262 VULKAN_HPP_NOEXCEPT; 5263 5264 //=== VK_EXT_multi_draw === 5265 5266 void drawMultiEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo, 5267 uint32_t instanceCount, 5268 uint32_t firstInstance, 5269 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5270 5271 void drawMultiIndexedEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo, 5272 uint32_t instanceCount, 5273 uint32_t firstInstance, 5274 uint32_t stride, 5275 Optional<const int32_t> vertexOffset 5276 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5277 5278 private: 5279 VULKAN_HPP_NAMESPACE::Device m_device = {}; 5280 VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; 5281 VULKAN_HPP_NAMESPACE::CommandBuffer m_commandBuffer = {}; 5282 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 5283 }; 5284 5285 class CommandBuffers : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> 5286 { 5287 public: CommandBuffers(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo)5288 CommandBuffers( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5289 VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) 5290 { 5291 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * dispatcher = device.getDispatcher(); 5292 std::vector<VkCommandBuffer> commandBuffers( allocateInfo.commandBufferCount ); 5293 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 5294 dispatcher->vkAllocateCommandBuffers( static_cast<VkDevice>( *device ), 5295 reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), 5296 commandBuffers.data() ) ); 5297 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 5298 { 5299 this->reserve( allocateInfo.commandBufferCount ); 5300 for ( auto const & commandBuffer : commandBuffers ) 5301 { 5302 this->emplace_back( device, commandBuffer, static_cast<VkCommandPool>( allocateInfo.commandPool ) ); 5303 } 5304 } 5305 else 5306 { 5307 throwResultException( result, "vkAllocateCommandBuffers" ); 5308 } 5309 } 5310 5311 CommandBuffers() = delete; 5312 CommandBuffers( CommandBuffers const & ) = delete; 5313 CommandBuffers( CommandBuffers && rhs ) = default; 5314 CommandBuffers & operator=( CommandBuffers const & ) = delete; 5315 CommandBuffers & operator=( CommandBuffers && rhs ) = default; 5316 }; 5317 5318 class CuFunctionNVX 5319 { 5320 public: 5321 using CType = VkCuFunctionNVX; 5322 5323 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 5324 VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX; 5325 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5326 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX; 5327 5328 public: CuFunctionNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5329 CuFunctionNVX( 5330 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5331 VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo, 5332 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5333 : m_device( *device ) 5334 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5335 , m_dispatcher( device.getDispatcher() ) 5336 { 5337 VULKAN_HPP_NAMESPACE::Result result = 5338 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateCuFunctionNVX( 5339 static_cast<VkDevice>( *device ), 5340 reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ), 5341 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 5342 reinterpret_cast<VkCuFunctionNVX *>( &m_function ) ) ); 5343 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 5344 { 5345 throwResultException( result, "vkCreateCuFunctionNVX" ); 5346 } 5347 } 5348 CuFunctionNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCuFunctionNVX function,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5349 CuFunctionNVX( 5350 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5351 VkCuFunctionNVX function, 5352 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5353 : m_device( *device ) 5354 , m_function( function ) 5355 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5356 , m_dispatcher( device.getDispatcher() ) 5357 {} 5358 CuFunctionNVX(std::nullptr_t)5359 CuFunctionNVX( std::nullptr_t ) {} 5360 ~CuFunctionNVX()5361 ~CuFunctionNVX() 5362 { 5363 if ( m_function ) 5364 { 5365 getDispatcher()->vkDestroyCuFunctionNVX( static_cast<VkDevice>( m_device ), 5366 static_cast<VkCuFunctionNVX>( m_function ), 5367 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5368 } 5369 } 5370 5371 CuFunctionNVX() = delete; 5372 CuFunctionNVX( CuFunctionNVX const & ) = delete; CuFunctionNVX(CuFunctionNVX && rhs)5373 CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT 5374 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 5375 , m_function( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} ) ) 5376 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5377 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5378 {} 5379 CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete; operator =(CuFunctionNVX && rhs)5380 CuFunctionNVX & operator =( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT 5381 { 5382 if ( this != &rhs ) 5383 { 5384 if ( m_function ) 5385 { 5386 getDispatcher()->vkDestroyCuFunctionNVX( static_cast<VkDevice>( m_device ), 5387 static_cast<VkCuFunctionNVX>( m_function ), 5388 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5389 } 5390 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 5391 m_function = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} ); 5392 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 5393 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 5394 } 5395 return *this; 5396 } 5397 operator *() const5398 VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT 5399 { 5400 return m_function; 5401 } 5402 getDevice() const5403 VULKAN_HPP_NAMESPACE::Device getDevice() const 5404 { 5405 return m_device; 5406 } 5407 getDispatcher() const5408 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 5409 { 5410 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5411 return m_dispatcher; 5412 } 5413 5414 private: 5415 VULKAN_HPP_NAMESPACE::Device m_device = {}; 5416 VULKAN_HPP_NAMESPACE::CuFunctionNVX m_function = {}; 5417 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 5418 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 5419 }; 5420 5421 class CuModuleNVX 5422 { 5423 public: 5424 using CType = VkCuModuleNVX; 5425 5426 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 5427 VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX; 5428 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5429 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX; 5430 5431 public: CuModuleNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5432 CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5433 VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo, 5434 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5435 : m_device( *device ) 5436 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5437 , m_dispatcher( device.getDispatcher() ) 5438 { 5439 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 5440 device.getDispatcher()->vkCreateCuModuleNVX( static_cast<VkDevice>( *device ), 5441 reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ), 5442 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 5443 reinterpret_cast<VkCuModuleNVX *>( &m_module ) ) ); 5444 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 5445 { 5446 throwResultException( result, "vkCreateCuModuleNVX" ); 5447 } 5448 } 5449 CuModuleNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCuModuleNVX module,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5450 CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5451 VkCuModuleNVX module, 5452 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5453 : m_device( *device ) 5454 , m_module( module ) 5455 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5456 , m_dispatcher( device.getDispatcher() ) 5457 {} 5458 CuModuleNVX(std::nullptr_t)5459 CuModuleNVX( std::nullptr_t ) {} 5460 ~CuModuleNVX()5461 ~CuModuleNVX() 5462 { 5463 if ( m_module ) 5464 { 5465 getDispatcher()->vkDestroyCuModuleNVX( static_cast<VkDevice>( m_device ), 5466 static_cast<VkCuModuleNVX>( m_module ), 5467 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5468 } 5469 } 5470 5471 CuModuleNVX() = delete; 5472 CuModuleNVX( CuModuleNVX const & ) = delete; CuModuleNVX(CuModuleNVX && rhs)5473 CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT 5474 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 5475 , m_module( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} ) ) 5476 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5477 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5478 {} 5479 CuModuleNVX & operator=( CuModuleNVX const & ) = delete; operator =(CuModuleNVX && rhs)5480 CuModuleNVX & operator =( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT 5481 { 5482 if ( this != &rhs ) 5483 { 5484 if ( m_module ) 5485 { 5486 getDispatcher()->vkDestroyCuModuleNVX( static_cast<VkDevice>( m_device ), 5487 static_cast<VkCuModuleNVX>( m_module ), 5488 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5489 } 5490 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 5491 m_module = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} ); 5492 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 5493 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 5494 } 5495 return *this; 5496 } 5497 operator *() const5498 VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const VULKAN_HPP_NOEXCEPT 5499 { 5500 return m_module; 5501 } 5502 getDevice() const5503 VULKAN_HPP_NAMESPACE::Device getDevice() const 5504 { 5505 return m_device; 5506 } 5507 getDispatcher() const5508 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 5509 { 5510 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5511 return m_dispatcher; 5512 } 5513 5514 private: 5515 VULKAN_HPP_NAMESPACE::Device m_device = {}; 5516 VULKAN_HPP_NAMESPACE::CuModuleNVX m_module = {}; 5517 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 5518 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 5519 }; 5520 5521 class DebugReportCallbackEXT 5522 { 5523 public: 5524 using CType = VkDebugReportCallbackEXT; 5525 5526 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 5527 VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT; 5528 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5529 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT; 5530 5531 public: DebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5532 DebugReportCallbackEXT( 5533 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 5534 VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo, 5535 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5536 : m_instance( *instance ) 5537 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5538 , m_dispatcher( instance.getDispatcher() ) 5539 { 5540 VULKAN_HPP_NAMESPACE::Result result = 5541 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateDebugReportCallbackEXT( 5542 static_cast<VkInstance>( *instance ), 5543 reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ), 5544 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 5545 reinterpret_cast<VkDebugReportCallbackEXT *>( &m_callback ) ) ); 5546 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 5547 { 5548 throwResultException( result, "vkCreateDebugReportCallbackEXT" ); 5549 } 5550 } 5551 DebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VkDebugReportCallbackEXT callback,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5552 DebugReportCallbackEXT( 5553 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 5554 VkDebugReportCallbackEXT callback, 5555 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5556 : m_instance( *instance ) 5557 , m_callback( callback ) 5558 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5559 , m_dispatcher( instance.getDispatcher() ) 5560 {} 5561 DebugReportCallbackEXT(std::nullptr_t)5562 DebugReportCallbackEXT( std::nullptr_t ) {} 5563 ~DebugReportCallbackEXT()5564 ~DebugReportCallbackEXT() 5565 { 5566 if ( m_callback ) 5567 { 5568 getDispatcher()->vkDestroyDebugReportCallbackEXT( 5569 static_cast<VkInstance>( m_instance ), 5570 static_cast<VkDebugReportCallbackEXT>( m_callback ), 5571 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5572 } 5573 } 5574 5575 DebugReportCallbackEXT() = delete; 5576 DebugReportCallbackEXT( DebugReportCallbackEXT const & ) = delete; DebugReportCallbackEXT(DebugReportCallbackEXT && rhs)5577 DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT 5578 : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) 5579 , m_callback( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_callback, {} ) ) 5580 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5581 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5582 {} 5583 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & ) = delete; operator =(DebugReportCallbackEXT && rhs)5584 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT 5585 { 5586 if ( this != &rhs ) 5587 { 5588 if ( m_callback ) 5589 { 5590 getDispatcher()->vkDestroyDebugReportCallbackEXT( 5591 static_cast<VkInstance>( m_instance ), 5592 static_cast<VkDebugReportCallbackEXT>( m_callback ), 5593 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5594 } 5595 m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); 5596 m_callback = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_callback, {} ); 5597 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 5598 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 5599 } 5600 return *this; 5601 } 5602 operator *() const5603 VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const VULKAN_HPP_NOEXCEPT 5604 { 5605 return m_callback; 5606 } 5607 getInstance() const5608 VULKAN_HPP_NAMESPACE::Instance getInstance() const 5609 { 5610 return m_instance; 5611 } 5612 getDispatcher() const5613 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 5614 { 5615 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5616 return m_dispatcher; 5617 } 5618 5619 private: 5620 VULKAN_HPP_NAMESPACE::Instance m_instance = {}; 5621 VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_callback = {}; 5622 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 5623 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 5624 }; 5625 5626 class DebugUtilsMessengerEXT 5627 { 5628 public: 5629 using CType = VkDebugUtilsMessengerEXT; 5630 5631 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 5632 VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT; 5633 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5634 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 5635 5636 public: DebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5637 DebugUtilsMessengerEXT( 5638 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 5639 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo, 5640 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5641 : m_instance( *instance ) 5642 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5643 , m_dispatcher( instance.getDispatcher() ) 5644 { 5645 VULKAN_HPP_NAMESPACE::Result result = 5646 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateDebugUtilsMessengerEXT( 5647 static_cast<VkInstance>( *instance ), 5648 reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ), 5649 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 5650 reinterpret_cast<VkDebugUtilsMessengerEXT *>( &m_messenger ) ) ); 5651 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 5652 { 5653 throwResultException( result, "vkCreateDebugUtilsMessengerEXT" ); 5654 } 5655 } 5656 DebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VkDebugUtilsMessengerEXT messenger,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5657 DebugUtilsMessengerEXT( 5658 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 5659 VkDebugUtilsMessengerEXT messenger, 5660 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5661 : m_instance( *instance ) 5662 , m_messenger( messenger ) 5663 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5664 , m_dispatcher( instance.getDispatcher() ) 5665 {} 5666 DebugUtilsMessengerEXT(std::nullptr_t)5667 DebugUtilsMessengerEXT( std::nullptr_t ) {} 5668 ~DebugUtilsMessengerEXT()5669 ~DebugUtilsMessengerEXT() 5670 { 5671 if ( m_messenger ) 5672 { 5673 getDispatcher()->vkDestroyDebugUtilsMessengerEXT( 5674 static_cast<VkInstance>( m_instance ), 5675 static_cast<VkDebugUtilsMessengerEXT>( m_messenger ), 5676 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5677 } 5678 } 5679 5680 DebugUtilsMessengerEXT() = delete; 5681 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & ) = delete; DebugUtilsMessengerEXT(DebugUtilsMessengerEXT && rhs)5682 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT 5683 : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) 5684 , m_messenger( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} ) ) 5685 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5686 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5687 {} 5688 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & ) = delete; operator =(DebugUtilsMessengerEXT && rhs)5689 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT 5690 { 5691 if ( this != &rhs ) 5692 { 5693 if ( m_messenger ) 5694 { 5695 getDispatcher()->vkDestroyDebugUtilsMessengerEXT( 5696 static_cast<VkInstance>( m_instance ), 5697 static_cast<VkDebugUtilsMessengerEXT>( m_messenger ), 5698 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5699 } 5700 m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); 5701 m_messenger = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} ); 5702 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 5703 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 5704 } 5705 return *this; 5706 } 5707 operator *() const5708 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const VULKAN_HPP_NOEXCEPT 5709 { 5710 return m_messenger; 5711 } 5712 getInstance() const5713 VULKAN_HPP_NAMESPACE::Instance getInstance() const 5714 { 5715 return m_instance; 5716 } 5717 getDispatcher() const5718 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 5719 { 5720 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5721 return m_dispatcher; 5722 } 5723 5724 private: 5725 VULKAN_HPP_NAMESPACE::Instance m_instance = {}; 5726 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_messenger = {}; 5727 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 5728 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 5729 }; 5730 5731 class DeferredOperationKHR 5732 { 5733 public: 5734 using CType = VkDeferredOperationKHR; 5735 5736 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 5737 VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR; 5738 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5739 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 5740 5741 public: DeferredOperationKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5742 DeferredOperationKHR( 5743 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5744 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5745 : m_device( *device ) 5746 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5747 , m_dispatcher( device.getDispatcher() ) 5748 { 5749 VULKAN_HPP_NAMESPACE::Result result = 5750 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateDeferredOperationKHR( 5751 static_cast<VkDevice>( *device ), 5752 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 5753 reinterpret_cast<VkDeferredOperationKHR *>( &m_operation ) ) ); 5754 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 5755 { 5756 throwResultException( result, "vkCreateDeferredOperationKHR" ); 5757 } 5758 } 5759 DeferredOperationKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDeferredOperationKHR operation,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5760 DeferredOperationKHR( 5761 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5762 VkDeferredOperationKHR operation, 5763 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5764 : m_device( *device ) 5765 , m_operation( operation ) 5766 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5767 , m_dispatcher( device.getDispatcher() ) 5768 {} 5769 DeferredOperationKHR(std::nullptr_t)5770 DeferredOperationKHR( std::nullptr_t ) {} 5771 ~DeferredOperationKHR()5772 ~DeferredOperationKHR() 5773 { 5774 if ( m_operation ) 5775 { 5776 getDispatcher()->vkDestroyDeferredOperationKHR( 5777 static_cast<VkDevice>( m_device ), 5778 static_cast<VkDeferredOperationKHR>( m_operation ), 5779 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5780 } 5781 } 5782 5783 DeferredOperationKHR() = delete; 5784 DeferredOperationKHR( DeferredOperationKHR const & ) = delete; DeferredOperationKHR(DeferredOperationKHR && rhs)5785 DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT 5786 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 5787 , m_operation( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_operation, {} ) ) 5788 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5789 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5790 {} 5791 DeferredOperationKHR & operator=( DeferredOperationKHR const & ) = delete; operator =(DeferredOperationKHR && rhs)5792 DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT 5793 { 5794 if ( this != &rhs ) 5795 { 5796 if ( m_operation ) 5797 { 5798 getDispatcher()->vkDestroyDeferredOperationKHR( 5799 static_cast<VkDevice>( m_device ), 5800 static_cast<VkDeferredOperationKHR>( m_operation ), 5801 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5802 } 5803 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 5804 m_operation = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_operation, {} ); 5805 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 5806 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 5807 } 5808 return *this; 5809 } 5810 operator *() const5811 VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const VULKAN_HPP_NOEXCEPT 5812 { 5813 return m_operation; 5814 } 5815 getDevice() const5816 VULKAN_HPP_NAMESPACE::Device getDevice() const 5817 { 5818 return m_device; 5819 } 5820 getDispatcher() const5821 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 5822 { 5823 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5824 return m_dispatcher; 5825 } 5826 5827 //=== VK_KHR_deferred_host_operations === 5828 5829 VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT; 5830 5831 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getResult() const VULKAN_HPP_NOEXCEPT; 5832 5833 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result join() const; 5834 5835 private: 5836 VULKAN_HPP_NAMESPACE::Device m_device = {}; 5837 VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_operation = {}; 5838 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 5839 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 5840 }; 5841 5842 class DescriptorPool 5843 { 5844 public: 5845 using CType = VkDescriptorPool; 5846 5847 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 5848 VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool; 5849 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5850 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool; 5851 5852 public: DescriptorPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5853 DescriptorPool( 5854 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5855 VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo, 5856 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5857 : m_device( *device ) 5858 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5859 , m_dispatcher( device.getDispatcher() ) 5860 { 5861 VULKAN_HPP_NAMESPACE::Result result = 5862 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateDescriptorPool( 5863 static_cast<VkDevice>( *device ), 5864 reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ), 5865 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 5866 reinterpret_cast<VkDescriptorPool *>( &m_descriptorPool ) ) ); 5867 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 5868 { 5869 throwResultException( result, "vkCreateDescriptorPool" ); 5870 } 5871 } 5872 DescriptorPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDescriptorPool descriptorPool,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5873 DescriptorPool( 5874 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5875 VkDescriptorPool descriptorPool, 5876 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5877 : m_device( *device ) 5878 , m_descriptorPool( descriptorPool ) 5879 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5880 , m_dispatcher( device.getDispatcher() ) 5881 {} 5882 DescriptorPool(std::nullptr_t)5883 DescriptorPool( std::nullptr_t ) {} 5884 ~DescriptorPool()5885 ~DescriptorPool() 5886 { 5887 if ( m_descriptorPool ) 5888 { 5889 getDispatcher()->vkDestroyDescriptorPool( static_cast<VkDevice>( m_device ), 5890 static_cast<VkDescriptorPool>( m_descriptorPool ), 5891 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5892 } 5893 } 5894 5895 DescriptorPool() = delete; 5896 DescriptorPool( DescriptorPool const & ) = delete; DescriptorPool(DescriptorPool && rhs)5897 DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT 5898 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 5899 , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) 5900 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5901 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5902 {} 5903 DescriptorPool & operator=( DescriptorPool const & ) = delete; operator =(DescriptorPool && rhs)5904 DescriptorPool & operator =( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT 5905 { 5906 if ( this != &rhs ) 5907 { 5908 if ( m_descriptorPool ) 5909 { 5910 getDispatcher()->vkDestroyDescriptorPool( static_cast<VkDevice>( m_device ), 5911 static_cast<VkDescriptorPool>( m_descriptorPool ), 5912 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5913 } 5914 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 5915 m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ); 5916 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 5917 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 5918 } 5919 return *this; 5920 } 5921 operator *() const5922 VULKAN_HPP_NAMESPACE::DescriptorPool const & operator*() const VULKAN_HPP_NOEXCEPT 5923 { 5924 return m_descriptorPool; 5925 } 5926 getDevice() const5927 VULKAN_HPP_NAMESPACE::Device getDevice() const 5928 { 5929 return m_device; 5930 } 5931 getDispatcher() const5932 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 5933 { 5934 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5935 return m_dispatcher; 5936 } 5937 5938 //=== VK_VERSION_1_0 === 5939 5940 void reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const 5941 VULKAN_HPP_NOEXCEPT; 5942 5943 private: 5944 VULKAN_HPP_NAMESPACE::Device m_device = {}; 5945 VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; 5946 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 5947 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 5948 }; 5949 5950 class DescriptorSet 5951 { 5952 public: 5953 using CType = VkDescriptorSet; 5954 5955 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 5956 VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet; 5957 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5958 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet; 5959 5960 public: DescriptorSet(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDescriptorSet descriptorSet,VkDescriptorPool descriptorPool)5961 DescriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5962 VkDescriptorSet descriptorSet, 5963 VkDescriptorPool descriptorPool ) 5964 : m_device( *device ) 5965 , m_descriptorPool( descriptorPool ) 5966 , m_descriptorSet( descriptorSet ) 5967 , m_dispatcher( device.getDispatcher() ) 5968 {} 5969 DescriptorSet(std::nullptr_t)5970 DescriptorSet( std::nullptr_t ) {} 5971 ~DescriptorSet()5972 ~DescriptorSet() 5973 { 5974 if ( m_descriptorSet ) 5975 { 5976 getDispatcher()->vkFreeDescriptorSets( static_cast<VkDevice>( m_device ), 5977 static_cast<VkDescriptorPool>( m_descriptorPool ), 5978 1, 5979 reinterpret_cast<VkDescriptorSet const *>( &m_descriptorSet ) ); 5980 } 5981 } 5982 5983 DescriptorSet() = delete; 5984 DescriptorSet( DescriptorSet const & ) = delete; DescriptorSet(DescriptorSet && rhs)5985 DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT 5986 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 5987 , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) 5988 , m_descriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) ) 5989 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5990 {} 5991 DescriptorSet & operator=( DescriptorSet const & ) = delete; operator =(DescriptorSet && rhs)5992 DescriptorSet & operator =( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT 5993 { 5994 if ( this != &rhs ) 5995 { 5996 if ( m_descriptorSet ) 5997 { 5998 getDispatcher()->vkFreeDescriptorSets( static_cast<VkDevice>( m_device ), 5999 static_cast<VkDescriptorPool>( m_descriptorPool ), 6000 1, 6001 reinterpret_cast<VkDescriptorSet const *>( &m_descriptorSet ) ); 6002 } 6003 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 6004 m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ); 6005 m_descriptorSet = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} ); 6006 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 6007 } 6008 return *this; 6009 } 6010 operator *() const6011 VULKAN_HPP_NAMESPACE::DescriptorSet const & operator*() const VULKAN_HPP_NOEXCEPT 6012 { 6013 return m_descriptorSet; 6014 } 6015 getDevice() const6016 VULKAN_HPP_NAMESPACE::Device getDevice() const 6017 { 6018 return m_device; 6019 } 6020 getDispatcher() const6021 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 6022 { 6023 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6024 return m_dispatcher; 6025 } 6026 6027 //=== VK_VERSION_1_1 === 6028 6029 void updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 6030 const void * pData ) const VULKAN_HPP_NOEXCEPT; 6031 6032 //=== VK_KHR_descriptor_update_template === 6033 6034 void updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 6035 const void * pData ) const VULKAN_HPP_NOEXCEPT; 6036 6037 private: 6038 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6039 VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; 6040 VULKAN_HPP_NAMESPACE::DescriptorSet m_descriptorSet = {}; 6041 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6042 }; 6043 6044 class DescriptorSets : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> 6045 { 6046 public: DescriptorSets(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo)6047 DescriptorSets( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6048 VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) 6049 { 6050 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * dispatcher = device.getDispatcher(); 6051 std::vector<VkDescriptorSet> descriptorSets( allocateInfo.descriptorSetCount ); 6052 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 6053 dispatcher->vkAllocateDescriptorSets( static_cast<VkDevice>( *device ), 6054 reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), 6055 descriptorSets.data() ) ); 6056 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6057 { 6058 this->reserve( allocateInfo.descriptorSetCount ); 6059 for ( auto const & descriptorSet : descriptorSets ) 6060 { 6061 this->emplace_back( device, descriptorSet, static_cast<VkDescriptorPool>( allocateInfo.descriptorPool ) ); 6062 } 6063 } 6064 else 6065 { 6066 throwResultException( result, "vkAllocateDescriptorSets" ); 6067 } 6068 } 6069 6070 DescriptorSets() = delete; 6071 DescriptorSets( DescriptorSets const & ) = delete; 6072 DescriptorSets( DescriptorSets && rhs ) = default; 6073 DescriptorSets & operator=( DescriptorSets const & ) = delete; 6074 DescriptorSets & operator=( DescriptorSets && rhs ) = default; 6075 }; 6076 6077 class DescriptorSetLayout 6078 { 6079 public: 6080 using CType = VkDescriptorSetLayout; 6081 6082 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 6083 VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout; 6084 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6085 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout; 6086 6087 public: DescriptorSetLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6088 DescriptorSetLayout( 6089 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6090 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo, 6091 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6092 : m_device( *device ) 6093 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6094 , m_dispatcher( device.getDispatcher() ) 6095 { 6096 VULKAN_HPP_NAMESPACE::Result result = 6097 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateDescriptorSetLayout( 6098 static_cast<VkDevice>( *device ), 6099 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 6100 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 6101 reinterpret_cast<VkDescriptorSetLayout *>( &m_descriptorSetLayout ) ) ); 6102 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6103 { 6104 throwResultException( result, "vkCreateDescriptorSetLayout" ); 6105 } 6106 } 6107 DescriptorSetLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDescriptorSetLayout descriptorSetLayout,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6108 DescriptorSetLayout( 6109 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6110 VkDescriptorSetLayout descriptorSetLayout, 6111 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6112 : m_device( *device ) 6113 , m_descriptorSetLayout( descriptorSetLayout ) 6114 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6115 , m_dispatcher( device.getDispatcher() ) 6116 {} 6117 DescriptorSetLayout(std::nullptr_t)6118 DescriptorSetLayout( std::nullptr_t ) {} 6119 ~DescriptorSetLayout()6120 ~DescriptorSetLayout() 6121 { 6122 if ( m_descriptorSetLayout ) 6123 { 6124 getDispatcher()->vkDestroyDescriptorSetLayout( 6125 static_cast<VkDevice>( m_device ), 6126 static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ), 6127 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6128 } 6129 } 6130 6131 DescriptorSetLayout() = delete; 6132 DescriptorSetLayout( DescriptorSetLayout const & ) = delete; DescriptorSetLayout(DescriptorSetLayout && rhs)6133 DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT 6134 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 6135 , m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, 6136 {} ) ) 6137 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6138 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6139 {} 6140 DescriptorSetLayout & operator=( DescriptorSetLayout const & ) = delete; operator =(DescriptorSetLayout && rhs)6141 DescriptorSetLayout & operator =( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT 6142 { 6143 if ( this != &rhs ) 6144 { 6145 if ( m_descriptorSetLayout ) 6146 { 6147 getDispatcher()->vkDestroyDescriptorSetLayout( 6148 static_cast<VkDevice>( m_device ), 6149 static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ), 6150 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6151 } 6152 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 6153 m_descriptorSetLayout = 6154 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ); 6155 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 6156 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 6157 } 6158 return *this; 6159 } 6160 operator *() const6161 VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & operator*() const VULKAN_HPP_NOEXCEPT 6162 { 6163 return m_descriptorSetLayout; 6164 } 6165 getDevice() const6166 VULKAN_HPP_NAMESPACE::Device getDevice() const 6167 { 6168 return m_device; 6169 } 6170 getDispatcher() const6171 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 6172 { 6173 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6174 return m_dispatcher; 6175 } 6176 6177 private: 6178 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6179 VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout = {}; 6180 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 6181 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6182 }; 6183 6184 class DescriptorUpdateTemplate 6185 { 6186 public: 6187 using CType = VkDescriptorUpdateTemplate; 6188 6189 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 6190 VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate; 6191 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6192 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; 6193 6194 public: DescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6195 DescriptorUpdateTemplate( 6196 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6197 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 6198 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6199 : m_device( *device ) 6200 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6201 , m_dispatcher( device.getDispatcher() ) 6202 { 6203 VULKAN_HPP_NAMESPACE::Result result = 6204 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateDescriptorUpdateTemplate( 6205 static_cast<VkDevice>( *device ), 6206 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ), 6207 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 6208 reinterpret_cast<VkDescriptorUpdateTemplate *>( &m_descriptorUpdateTemplate ) ) ); 6209 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6210 { 6211 throwResultException( result, "vkCreateDescriptorUpdateTemplate" ); 6212 } 6213 } 6214 DescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDescriptorUpdateTemplate descriptorUpdateTemplate,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6215 DescriptorUpdateTemplate( 6216 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6217 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 6218 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6219 : m_device( *device ) 6220 , m_descriptorUpdateTemplate( descriptorUpdateTemplate ) 6221 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6222 , m_dispatcher( device.getDispatcher() ) 6223 {} 6224 DescriptorUpdateTemplate(std::nullptr_t)6225 DescriptorUpdateTemplate( std::nullptr_t ) {} 6226 ~DescriptorUpdateTemplate()6227 ~DescriptorUpdateTemplate() 6228 { 6229 if ( m_descriptorUpdateTemplate ) 6230 { 6231 getDispatcher()->vkDestroyDescriptorUpdateTemplate( 6232 static_cast<VkDevice>( m_device ), 6233 static_cast<VkDescriptorUpdateTemplate>( m_descriptorUpdateTemplate ), 6234 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6235 } 6236 } 6237 6238 DescriptorUpdateTemplate() = delete; 6239 DescriptorUpdateTemplate( DescriptorUpdateTemplate const & ) = delete; DescriptorUpdateTemplate(DescriptorUpdateTemplate && rhs)6240 DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT 6241 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 6242 , m_descriptorUpdateTemplate( 6243 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ) ) 6244 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6245 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6246 {} 6247 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & ) = delete; operator =(DescriptorUpdateTemplate && rhs)6248 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT 6249 { 6250 if ( this != &rhs ) 6251 { 6252 if ( m_descriptorUpdateTemplate ) 6253 { 6254 getDispatcher()->vkDestroyDescriptorUpdateTemplate( 6255 static_cast<VkDevice>( m_device ), 6256 static_cast<VkDescriptorUpdateTemplate>( m_descriptorUpdateTemplate ), 6257 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6258 } 6259 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 6260 m_descriptorUpdateTemplate = 6261 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ); 6262 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 6263 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 6264 } 6265 return *this; 6266 } 6267 operator *() const6268 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & operator*() const VULKAN_HPP_NOEXCEPT 6269 { 6270 return m_descriptorUpdateTemplate; 6271 } 6272 getDevice() const6273 VULKAN_HPP_NAMESPACE::Device getDevice() const 6274 { 6275 return m_device; 6276 } 6277 getDispatcher() const6278 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 6279 { 6280 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6281 return m_dispatcher; 6282 } 6283 6284 private: 6285 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6286 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; 6287 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 6288 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6289 }; 6290 6291 class DeviceMemory 6292 { 6293 public: 6294 using CType = VkDeviceMemory; 6295 6296 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 6297 VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory; 6298 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6299 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory; 6300 6301 public: DeviceMemory(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6302 DeviceMemory( 6303 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6304 VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo, 6305 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6306 : m_device( *device ) 6307 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6308 , m_dispatcher( device.getDispatcher() ) 6309 { 6310 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 6311 device.getDispatcher()->vkAllocateMemory( static_cast<VkDevice>( *device ), 6312 reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ), 6313 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 6314 reinterpret_cast<VkDeviceMemory *>( &m_memory ) ) ); 6315 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6316 { 6317 throwResultException( result, "vkAllocateMemory" ); 6318 } 6319 } 6320 DeviceMemory(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDeviceMemory memory,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6321 DeviceMemory( 6322 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6323 VkDeviceMemory memory, 6324 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6325 : m_device( *device ) 6326 , m_memory( memory ) 6327 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6328 , m_dispatcher( device.getDispatcher() ) 6329 {} 6330 DeviceMemory(std::nullptr_t)6331 DeviceMemory( std::nullptr_t ) {} 6332 ~DeviceMemory()6333 ~DeviceMemory() 6334 { 6335 if ( m_memory ) 6336 { 6337 getDispatcher()->vkFreeMemory( static_cast<VkDevice>( m_device ), 6338 static_cast<VkDeviceMemory>( m_memory ), 6339 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6340 } 6341 } 6342 6343 DeviceMemory() = delete; 6344 DeviceMemory( DeviceMemory const & ) = delete; DeviceMemory(DeviceMemory && rhs)6345 DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT 6346 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 6347 , m_memory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} ) ) 6348 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6349 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6350 {} 6351 DeviceMemory & operator=( DeviceMemory const & ) = delete; operator =(DeviceMemory && rhs)6352 DeviceMemory & operator =( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT 6353 { 6354 if ( this != &rhs ) 6355 { 6356 if ( m_memory ) 6357 { 6358 getDispatcher()->vkFreeMemory( static_cast<VkDevice>( m_device ), 6359 static_cast<VkDeviceMemory>( m_memory ), 6360 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6361 } 6362 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 6363 m_memory = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} ); 6364 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 6365 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 6366 } 6367 return *this; 6368 } 6369 operator *() const6370 VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const VULKAN_HPP_NOEXCEPT 6371 { 6372 return m_memory; 6373 } 6374 getDevice() const6375 VULKAN_HPP_NAMESPACE::Device getDevice() const 6376 { 6377 return m_device; 6378 } 6379 getDispatcher() const6380 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 6381 { 6382 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6383 return m_dispatcher; 6384 } 6385 6386 //=== VK_VERSION_1_0 === 6387 6388 VULKAN_HPP_NODISCARD void * 6389 mapMemory( VULKAN_HPP_NAMESPACE::DeviceSize offset, 6390 VULKAN_HPP_NAMESPACE::DeviceSize size, 6391 VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 6392 6393 void unmapMemory() const VULKAN_HPP_NOEXCEPT; 6394 6395 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getCommitment() const VULKAN_HPP_NOEXCEPT; 6396 6397 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6398 //=== VK_NV_external_memory_win32 === 6399 6400 VULKAN_HPP_NODISCARD HANDLE 6401 getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const; 6402 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6403 6404 //=== VK_EXT_pageable_device_local_memory === 6405 6406 void setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT; 6407 6408 private: 6409 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6410 VULKAN_HPP_NAMESPACE::DeviceMemory m_memory = {}; 6411 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 6412 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6413 }; 6414 6415 class DisplayKHR 6416 { 6417 public: 6418 using CType = VkDisplayKHR; 6419 6420 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 6421 VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR; 6422 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6423 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR; 6424 6425 public: DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,int32_t drmFd,uint32_t connectorId)6426 DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, 6427 int32_t drmFd, 6428 uint32_t connectorId ) 6429 : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) 6430 { 6431 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 6432 physicalDevice.getDispatcher()->vkGetDrmDisplayEXT( static_cast<VkPhysicalDevice>( *physicalDevice ), 6433 drmFd, 6434 connectorId, 6435 reinterpret_cast<VkDisplayKHR *>( &m_display ) ) ); 6436 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6437 { 6438 throwResultException( result, "vkGetDrmDisplayEXT" ); 6439 } 6440 } 6441 6442 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,Display & dpy,RROutput rrOutput)6443 DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, 6444 Display & dpy, 6445 RROutput rrOutput ) 6446 : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) 6447 { 6448 VULKAN_HPP_NAMESPACE::Result result = 6449 static_cast<VULKAN_HPP_NAMESPACE::Result>( physicalDevice.getDispatcher()->vkGetRandROutputDisplayEXT( 6450 static_cast<VkPhysicalDevice>( *physicalDevice ), 6451 &dpy, 6452 rrOutput, 6453 reinterpret_cast<VkDisplayKHR *>( &m_display ) ) ); 6454 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6455 { 6456 throwResultException( result, "vkGetRandROutputDisplayEXT" ); 6457 } 6458 } 6459 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 6460 6461 # if defined( VK_USE_PLATFORM_WIN32_KHR ) DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,uint32_t deviceRelativeId)6462 DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, 6463 uint32_t deviceRelativeId ) 6464 : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() ) 6465 { 6466 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 6467 physicalDevice.getDispatcher()->vkGetWinrtDisplayNV( static_cast<VkPhysicalDevice>( *physicalDevice ), 6468 deviceRelativeId, 6469 reinterpret_cast<VkDisplayKHR *>( &m_display ) ) ); 6470 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6471 { 6472 throwResultException( result, "vkGetWinrtDisplayNV" ); 6473 } 6474 } 6475 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6476 DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,VkDisplayKHR display)6477 DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, 6478 VkDisplayKHR display ) 6479 : m_physicalDevice( *physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() ) 6480 {} 6481 DisplayKHR(std::nullptr_t)6482 DisplayKHR( std::nullptr_t ) {} 6483 ~DisplayKHR()6484 ~DisplayKHR() 6485 { 6486 if ( m_display ) 6487 { 6488 getDispatcher()->vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), 6489 static_cast<VkDisplayKHR>( m_display ) ); 6490 } 6491 } 6492 6493 DisplayKHR() = delete; 6494 DisplayKHR( DisplayKHR const & ) = delete; DisplayKHR(DisplayKHR && rhs)6495 DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT 6496 : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) 6497 , m_display( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} ) ) 6498 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6499 {} 6500 DisplayKHR & operator=( DisplayKHR const & ) = delete; operator =(DisplayKHR && rhs)6501 DisplayKHR & operator =( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT 6502 { 6503 if ( this != &rhs ) 6504 { 6505 if ( m_display ) 6506 { 6507 getDispatcher()->vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), 6508 static_cast<VkDisplayKHR>( m_display ) ); 6509 } 6510 m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ); 6511 m_display = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} ); 6512 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 6513 } 6514 return *this; 6515 } 6516 operator *() const6517 VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const VULKAN_HPP_NOEXCEPT 6518 { 6519 return m_display; 6520 } 6521 getPhysicalDevice() const6522 VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const 6523 { 6524 return m_physicalDevice; 6525 } 6526 getDispatcher() const6527 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 6528 { 6529 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6530 return m_dispatcher; 6531 } 6532 6533 //=== VK_KHR_display === 6534 6535 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const; 6536 6537 VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR createMode( 6538 VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, 6539 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 6540 6541 //=== VK_KHR_get_display_properties2 === 6542 6543 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const; 6544 6545 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6546 //=== VK_NV_acquire_winrt_display === 6547 6548 void acquireWinrtNV() const; 6549 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6550 6551 private: 6552 VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; 6553 VULKAN_HPP_NAMESPACE::DisplayKHR m_display = {}; 6554 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 6555 }; 6556 6557 class DisplayKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> 6558 { 6559 public: DisplayKHRs(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,uint32_t planeIndex)6560 DisplayKHRs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, 6561 uint32_t planeIndex ) 6562 { 6563 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * dispatcher = 6564 physicalDevice.getDispatcher(); 6565 std::vector<VkDisplayKHR> displays; 6566 uint32_t displayCount; 6567 VULKAN_HPP_NAMESPACE::Result result; 6568 do 6569 { 6570 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkGetDisplayPlaneSupportedDisplaysKHR( 6571 static_cast<VkPhysicalDevice>( *physicalDevice ), planeIndex, &displayCount, nullptr ) ); 6572 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && displayCount ) 6573 { 6574 displays.resize( displayCount ); 6575 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkGetDisplayPlaneSupportedDisplaysKHR( 6576 static_cast<VkPhysicalDevice>( *physicalDevice ), planeIndex, &displayCount, displays.data() ) ); 6577 } 6578 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 6579 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6580 { 6581 VULKAN_HPP_ASSERT( displayCount <= displays.size() ); 6582 this->reserve( displayCount ); 6583 for ( auto const & displayKHR : displays ) 6584 { 6585 this->emplace_back( physicalDevice, displayKHR ); 6586 } 6587 } 6588 else 6589 { 6590 throwResultException( result, "vkGetDisplayPlaneSupportedDisplaysKHR" ); 6591 } 6592 } 6593 6594 DisplayKHRs() = delete; 6595 DisplayKHRs( DisplayKHRs const & ) = delete; 6596 DisplayKHRs( DisplayKHRs && rhs ) = default; 6597 DisplayKHRs & operator=( DisplayKHRs const & ) = delete; 6598 DisplayKHRs & operator=( DisplayKHRs && rhs ) = default; 6599 }; 6600 6601 class DisplayModeKHR 6602 { 6603 public: 6604 using CType = VkDisplayModeKHR; 6605 6606 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 6607 VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR; 6608 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6609 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR; 6610 6611 public: DisplayModeKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6612 DisplayModeKHR( 6613 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, 6614 VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, 6615 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6616 : m_physicalDevice( display.getPhysicalDevice() ), m_dispatcher( display.getDispatcher() ) 6617 { 6618 VULKAN_HPP_NAMESPACE::Result result = 6619 static_cast<VULKAN_HPP_NAMESPACE::Result>( display.getDispatcher()->vkCreateDisplayModeKHR( 6620 static_cast<VkPhysicalDevice>( display.getPhysicalDevice() ), 6621 static_cast<VkDisplayKHR>( *display ), 6622 reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ), 6623 reinterpret_cast<const VkAllocationCallbacks *>( 6624 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 6625 reinterpret_cast<VkDisplayModeKHR *>( &m_displayModeKHR ) ) ); 6626 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6627 { 6628 throwResultException( result, "vkCreateDisplayModeKHR" ); 6629 } 6630 } 6631 DisplayModeKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,VkDisplayModeKHR displayModeKHR)6632 DisplayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, 6633 VkDisplayModeKHR displayModeKHR ) 6634 : m_physicalDevice( display.getPhysicalDevice() ) 6635 , m_displayModeKHR( displayModeKHR ) 6636 , m_dispatcher( display.getDispatcher() ) 6637 {} 6638 DisplayModeKHR(std::nullptr_t)6639 DisplayModeKHR( std::nullptr_t ) {} 6640 6641 DisplayModeKHR() = delete; 6642 DisplayModeKHR( DisplayModeKHR const & ) = delete; DisplayModeKHR(DisplayModeKHR && rhs)6643 DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT 6644 : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) 6645 , m_displayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) ) 6646 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6647 {} 6648 DisplayModeKHR & operator=( DisplayModeKHR const & ) = delete; operator =(DisplayModeKHR && rhs)6649 DisplayModeKHR & operator =( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT 6650 { 6651 if ( this != &rhs ) 6652 { 6653 m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ); 6654 m_displayModeKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ); 6655 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 6656 } 6657 return *this; 6658 } 6659 operator *() const6660 VULKAN_HPP_NAMESPACE::DisplayModeKHR const & operator*() const VULKAN_HPP_NOEXCEPT 6661 { 6662 return m_displayModeKHR; 6663 } 6664 getDispatcher() const6665 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 6666 { 6667 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6668 return m_dispatcher; 6669 } 6670 6671 //=== VK_KHR_display === 6672 6673 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR 6674 getDisplayPlaneCapabilities( uint32_t planeIndex ) const; 6675 6676 private: 6677 VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; 6678 VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR = {}; 6679 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 6680 }; 6681 6682 class Event 6683 { 6684 public: 6685 using CType = VkEvent; 6686 6687 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 6688 VULKAN_HPP_NAMESPACE::ObjectType::eEvent; 6689 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6690 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent; 6691 6692 public: Event(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6693 Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6694 VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo, 6695 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6696 : m_device( *device ) 6697 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6698 , m_dispatcher( device.getDispatcher() ) 6699 { 6700 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 6701 device.getDispatcher()->vkCreateEvent( static_cast<VkDevice>( *device ), 6702 reinterpret_cast<const VkEventCreateInfo *>( &createInfo ), 6703 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 6704 reinterpret_cast<VkEvent *>( &m_event ) ) ); 6705 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6706 { 6707 throwResultException( result, "vkCreateEvent" ); 6708 } 6709 } 6710 Event(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkEvent event,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6711 Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6712 VkEvent event, 6713 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6714 : m_device( *device ) 6715 , m_event( event ) 6716 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6717 , m_dispatcher( device.getDispatcher() ) 6718 {} 6719 Event(std::nullptr_t)6720 Event( std::nullptr_t ) {} 6721 ~Event()6722 ~Event() 6723 { 6724 if ( m_event ) 6725 { 6726 getDispatcher()->vkDestroyEvent( static_cast<VkDevice>( m_device ), 6727 static_cast<VkEvent>( m_event ), 6728 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6729 } 6730 } 6731 6732 Event() = delete; 6733 Event( Event const & ) = delete; Event(Event && rhs)6734 Event( Event && rhs ) VULKAN_HPP_NOEXCEPT 6735 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 6736 , m_event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} ) ) 6737 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6738 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6739 {} 6740 Event & operator=( Event const & ) = delete; operator =(Event && rhs)6741 Event & operator =( Event && rhs ) VULKAN_HPP_NOEXCEPT 6742 { 6743 if ( this != &rhs ) 6744 { 6745 if ( m_event ) 6746 { 6747 getDispatcher()->vkDestroyEvent( static_cast<VkDevice>( m_device ), 6748 static_cast<VkEvent>( m_event ), 6749 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6750 } 6751 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 6752 m_event = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} ); 6753 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 6754 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 6755 } 6756 return *this; 6757 } 6758 operator *() const6759 VULKAN_HPP_NAMESPACE::Event const & operator*() const VULKAN_HPP_NOEXCEPT 6760 { 6761 return m_event; 6762 } 6763 getDevice() const6764 VULKAN_HPP_NAMESPACE::Device getDevice() const 6765 { 6766 return m_device; 6767 } 6768 getDispatcher() const6769 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 6770 { 6771 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6772 return m_dispatcher; 6773 } 6774 6775 //=== VK_VERSION_1_0 === 6776 6777 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; 6778 6779 void set() const; 6780 6781 void reset() const; 6782 6783 private: 6784 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6785 VULKAN_HPP_NAMESPACE::Event m_event = {}; 6786 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 6787 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6788 }; 6789 6790 class Fence 6791 { 6792 public: 6793 using CType = VkFence; 6794 6795 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 6796 VULKAN_HPP_NAMESPACE::ObjectType::eFence; 6797 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6798 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence; 6799 6800 public: Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6801 Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6802 VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo, 6803 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6804 : m_device( *device ) 6805 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6806 , m_dispatcher( device.getDispatcher() ) 6807 { 6808 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 6809 device.getDispatcher()->vkCreateFence( static_cast<VkDevice>( *device ), 6810 reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ), 6811 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 6812 reinterpret_cast<VkFence *>( &m_fence ) ) ); 6813 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6814 { 6815 throwResultException( result, "vkCreateFence" ); 6816 } 6817 } 6818 Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6819 Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6820 VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo, 6821 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6822 : m_device( *device ) 6823 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6824 , m_dispatcher( device.getDispatcher() ) 6825 { 6826 VULKAN_HPP_NAMESPACE::Result result = 6827 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkRegisterDeviceEventEXT( 6828 static_cast<VkDevice>( *device ), 6829 reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ), 6830 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 6831 reinterpret_cast<VkFence *>( &m_fence ) ) ); 6832 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6833 { 6834 throwResultException( result, "vkRegisterDeviceEventEXT" ); 6835 } 6836 } 6837 Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6838 Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6839 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, 6840 VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo, 6841 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6842 : m_device( *device ) 6843 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6844 , m_dispatcher( device.getDispatcher() ) 6845 { 6846 VULKAN_HPP_NAMESPACE::Result result = 6847 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkRegisterDisplayEventEXT( 6848 static_cast<VkDevice>( *device ), 6849 static_cast<VkDisplayKHR>( *display ), 6850 reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ), 6851 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 6852 reinterpret_cast<VkFence *>( &m_fence ) ) ); 6853 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6854 { 6855 throwResultException( result, "vkRegisterDisplayEventEXT" ); 6856 } 6857 } 6858 Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkFence fence,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6859 Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6860 VkFence fence, 6861 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6862 : m_device( *device ) 6863 , m_fence( fence ) 6864 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6865 , m_dispatcher( device.getDispatcher() ) 6866 {} 6867 Fence(std::nullptr_t)6868 Fence( std::nullptr_t ) {} 6869 ~Fence()6870 ~Fence() 6871 { 6872 if ( m_fence ) 6873 { 6874 getDispatcher()->vkDestroyFence( static_cast<VkDevice>( m_device ), 6875 static_cast<VkFence>( m_fence ), 6876 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6877 } 6878 } 6879 6880 Fence() = delete; 6881 Fence( Fence const & ) = delete; Fence(Fence && rhs)6882 Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT 6883 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 6884 , m_fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} ) ) 6885 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6886 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6887 {} 6888 Fence & operator=( Fence const & ) = delete; operator =(Fence && rhs)6889 Fence & operator =( Fence && rhs ) VULKAN_HPP_NOEXCEPT 6890 { 6891 if ( this != &rhs ) 6892 { 6893 if ( m_fence ) 6894 { 6895 getDispatcher()->vkDestroyFence( static_cast<VkDevice>( m_device ), 6896 static_cast<VkFence>( m_fence ), 6897 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6898 } 6899 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 6900 m_fence = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} ); 6901 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 6902 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 6903 } 6904 return *this; 6905 } 6906 operator *() const6907 VULKAN_HPP_NAMESPACE::Fence const & operator*() const VULKAN_HPP_NOEXCEPT 6908 { 6909 return m_fence; 6910 } 6911 getDevice() const6912 VULKAN_HPP_NAMESPACE::Device getDevice() const 6913 { 6914 return m_device; 6915 } 6916 getDispatcher() const6917 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 6918 { 6919 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6920 return m_dispatcher; 6921 } 6922 6923 //=== VK_VERSION_1_0 === 6924 6925 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; 6926 6927 private: 6928 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6929 VULKAN_HPP_NAMESPACE::Fence m_fence = {}; 6930 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 6931 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6932 }; 6933 6934 class Framebuffer 6935 { 6936 public: 6937 using CType = VkFramebuffer; 6938 6939 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 6940 VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer; 6941 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6942 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer; 6943 6944 public: Framebuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6945 Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6946 VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo, 6947 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6948 : m_device( *device ) 6949 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6950 , m_dispatcher( device.getDispatcher() ) 6951 { 6952 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 6953 device.getDispatcher()->vkCreateFramebuffer( static_cast<VkDevice>( *device ), 6954 reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ), 6955 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 6956 reinterpret_cast<VkFramebuffer *>( &m_framebuffer ) ) ); 6957 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 6958 { 6959 throwResultException( result, "vkCreateFramebuffer" ); 6960 } 6961 } 6962 Framebuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkFramebuffer framebuffer,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6963 Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6964 VkFramebuffer framebuffer, 6965 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6966 : m_device( *device ) 6967 , m_framebuffer( framebuffer ) 6968 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6969 , m_dispatcher( device.getDispatcher() ) 6970 {} 6971 Framebuffer(std::nullptr_t)6972 Framebuffer( std::nullptr_t ) {} 6973 ~Framebuffer()6974 ~Framebuffer() 6975 { 6976 if ( m_framebuffer ) 6977 { 6978 getDispatcher()->vkDestroyFramebuffer( static_cast<VkDevice>( m_device ), 6979 static_cast<VkFramebuffer>( m_framebuffer ), 6980 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6981 } 6982 } 6983 6984 Framebuffer() = delete; 6985 Framebuffer( Framebuffer const & ) = delete; Framebuffer(Framebuffer && rhs)6986 Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT 6987 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 6988 , m_framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} ) ) 6989 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6990 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6991 {} 6992 Framebuffer & operator=( Framebuffer const & ) = delete; operator =(Framebuffer && rhs)6993 Framebuffer & operator =( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT 6994 { 6995 if ( this != &rhs ) 6996 { 6997 if ( m_framebuffer ) 6998 { 6999 getDispatcher()->vkDestroyFramebuffer( static_cast<VkDevice>( m_device ), 7000 static_cast<VkFramebuffer>( m_framebuffer ), 7001 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7002 } 7003 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 7004 m_framebuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} ); 7005 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 7006 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 7007 } 7008 return *this; 7009 } 7010 operator *() const7011 VULKAN_HPP_NAMESPACE::Framebuffer const & operator*() const VULKAN_HPP_NOEXCEPT 7012 { 7013 return m_framebuffer; 7014 } 7015 getDevice() const7016 VULKAN_HPP_NAMESPACE::Device getDevice() const 7017 { 7018 return m_device; 7019 } 7020 getDispatcher() const7021 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7022 { 7023 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7024 return m_dispatcher; 7025 } 7026 7027 private: 7028 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7029 VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer = {}; 7030 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 7031 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7032 }; 7033 7034 class Image 7035 { 7036 public: 7037 using CType = VkImage; 7038 7039 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 7040 VULKAN_HPP_NAMESPACE::ObjectType::eImage; 7041 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7042 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage; 7043 7044 public: Image(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7045 Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7046 VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo, 7047 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7048 : m_device( *device ) 7049 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7050 , m_dispatcher( device.getDispatcher() ) 7051 { 7052 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 7053 device.getDispatcher()->vkCreateImage( static_cast<VkDevice>( *device ), 7054 reinterpret_cast<const VkImageCreateInfo *>( &createInfo ), 7055 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 7056 reinterpret_cast<VkImage *>( &m_image ) ) ); 7057 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 7058 { 7059 throwResultException( result, "vkCreateImage" ); 7060 } 7061 } 7062 Image(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkImage image,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7063 Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7064 VkImage image, 7065 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7066 : m_device( *device ) 7067 , m_image( image ) 7068 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7069 , m_dispatcher( device.getDispatcher() ) 7070 {} 7071 Image(std::nullptr_t)7072 Image( std::nullptr_t ) {} 7073 ~Image()7074 ~Image() 7075 { 7076 if ( m_image ) 7077 { 7078 getDispatcher()->vkDestroyImage( static_cast<VkDevice>( m_device ), 7079 static_cast<VkImage>( m_image ), 7080 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7081 } 7082 } 7083 7084 Image() = delete; 7085 Image( Image const & ) = delete; Image(Image && rhs)7086 Image( Image && rhs ) VULKAN_HPP_NOEXCEPT 7087 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 7088 , m_image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} ) ) 7089 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7090 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7091 {} 7092 Image & operator=( Image const & ) = delete; operator =(Image && rhs)7093 Image & operator =( Image && rhs ) VULKAN_HPP_NOEXCEPT 7094 { 7095 if ( this != &rhs ) 7096 { 7097 if ( m_image ) 7098 { 7099 getDispatcher()->vkDestroyImage( static_cast<VkDevice>( m_device ), 7100 static_cast<VkImage>( m_image ), 7101 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7102 } 7103 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 7104 m_image = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} ); 7105 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 7106 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 7107 } 7108 return *this; 7109 } 7110 operator *() const7111 VULKAN_HPP_NAMESPACE::Image const & operator*() const VULKAN_HPP_NOEXCEPT 7112 { 7113 return m_image; 7114 } 7115 getDevice() const7116 VULKAN_HPP_NAMESPACE::Device getDevice() const 7117 { 7118 return m_device; 7119 } 7120 getDispatcher() const7121 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7122 { 7123 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7124 return m_dispatcher; 7125 } 7126 7127 //=== VK_VERSION_1_0 === 7128 7129 void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const; 7130 7131 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; 7132 7133 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> 7134 getSparseMemoryRequirements() const VULKAN_HPP_NOEXCEPT; 7135 7136 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout 7137 getSubresourceLayout( const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT; 7138 7139 //=== VK_EXT_image_drm_format_modifier === 7140 7141 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT 7142 getDrmFormatModifierPropertiesEXT() const; 7143 7144 private: 7145 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7146 VULKAN_HPP_NAMESPACE::Image m_image = {}; 7147 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 7148 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7149 }; 7150 7151 class ImageView 7152 { 7153 public: 7154 using CType = VkImageView; 7155 7156 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 7157 VULKAN_HPP_NAMESPACE::ObjectType::eImageView; 7158 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7159 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView; 7160 7161 public: ImageView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7162 ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7163 VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo, 7164 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7165 : m_device( *device ) 7166 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7167 , m_dispatcher( device.getDispatcher() ) 7168 { 7169 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 7170 device.getDispatcher()->vkCreateImageView( static_cast<VkDevice>( *device ), 7171 reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ), 7172 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 7173 reinterpret_cast<VkImageView *>( &m_imageView ) ) ); 7174 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 7175 { 7176 throwResultException( result, "vkCreateImageView" ); 7177 } 7178 } 7179 ImageView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkImageView imageView,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7180 ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7181 VkImageView imageView, 7182 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7183 : m_device( *device ) 7184 , m_imageView( imageView ) 7185 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7186 , m_dispatcher( device.getDispatcher() ) 7187 {} 7188 ImageView(std::nullptr_t)7189 ImageView( std::nullptr_t ) {} 7190 ~ImageView()7191 ~ImageView() 7192 { 7193 if ( m_imageView ) 7194 { 7195 getDispatcher()->vkDestroyImageView( static_cast<VkDevice>( m_device ), 7196 static_cast<VkImageView>( m_imageView ), 7197 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7198 } 7199 } 7200 7201 ImageView() = delete; 7202 ImageView( ImageView const & ) = delete; ImageView(ImageView && rhs)7203 ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT 7204 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 7205 , m_imageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} ) ) 7206 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7207 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7208 {} 7209 ImageView & operator=( ImageView const & ) = delete; operator =(ImageView && rhs)7210 ImageView & operator =( ImageView && rhs ) VULKAN_HPP_NOEXCEPT 7211 { 7212 if ( this != &rhs ) 7213 { 7214 if ( m_imageView ) 7215 { 7216 getDispatcher()->vkDestroyImageView( static_cast<VkDevice>( m_device ), 7217 static_cast<VkImageView>( m_imageView ), 7218 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7219 } 7220 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 7221 m_imageView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} ); 7222 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 7223 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 7224 } 7225 return *this; 7226 } 7227 operator *() const7228 VULKAN_HPP_NAMESPACE::ImageView const & operator*() const VULKAN_HPP_NOEXCEPT 7229 { 7230 return m_imageView; 7231 } 7232 getDevice() const7233 VULKAN_HPP_NAMESPACE::Device getDevice() const 7234 { 7235 return m_device; 7236 } 7237 getDispatcher() const7238 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7239 { 7240 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7241 return m_dispatcher; 7242 } 7243 7244 //=== VK_NVX_image_view_handle === 7245 7246 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const; 7247 7248 private: 7249 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7250 VULKAN_HPP_NAMESPACE::ImageView m_imageView = {}; 7251 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 7252 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7253 }; 7254 7255 class IndirectCommandsLayoutNV 7256 { 7257 public: 7258 using CType = VkIndirectCommandsLayoutNV; 7259 7260 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 7261 VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV; 7262 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7263 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 7264 7265 public: IndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7266 IndirectCommandsLayoutNV( 7267 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7268 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo, 7269 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7270 : m_device( *device ) 7271 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7272 , m_dispatcher( device.getDispatcher() ) 7273 { 7274 VULKAN_HPP_NAMESPACE::Result result = 7275 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateIndirectCommandsLayoutNV( 7276 static_cast<VkDevice>( *device ), 7277 reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ), 7278 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 7279 reinterpret_cast<VkIndirectCommandsLayoutNV *>( &m_indirectCommandsLayout ) ) ); 7280 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 7281 { 7282 throwResultException( result, "vkCreateIndirectCommandsLayoutNV" ); 7283 } 7284 } 7285 IndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkIndirectCommandsLayoutNV indirectCommandsLayout,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7286 IndirectCommandsLayoutNV( 7287 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7288 VkIndirectCommandsLayoutNV indirectCommandsLayout, 7289 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7290 : m_device( *device ) 7291 , m_indirectCommandsLayout( indirectCommandsLayout ) 7292 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7293 , m_dispatcher( device.getDispatcher() ) 7294 {} 7295 IndirectCommandsLayoutNV(std::nullptr_t)7296 IndirectCommandsLayoutNV( std::nullptr_t ) {} 7297 ~IndirectCommandsLayoutNV()7298 ~IndirectCommandsLayoutNV() 7299 { 7300 if ( m_indirectCommandsLayout ) 7301 { 7302 getDispatcher()->vkDestroyIndirectCommandsLayoutNV( 7303 static_cast<VkDevice>( m_device ), 7304 static_cast<VkIndirectCommandsLayoutNV>( m_indirectCommandsLayout ), 7305 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7306 } 7307 } 7308 7309 IndirectCommandsLayoutNV() = delete; 7310 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & ) = delete; IndirectCommandsLayoutNV(IndirectCommandsLayoutNV && rhs)7311 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT 7312 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 7313 , m_indirectCommandsLayout( 7314 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ) ) 7315 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7316 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7317 {} 7318 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & ) = delete; operator =(IndirectCommandsLayoutNV && rhs)7319 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT 7320 { 7321 if ( this != &rhs ) 7322 { 7323 if ( m_indirectCommandsLayout ) 7324 { 7325 getDispatcher()->vkDestroyIndirectCommandsLayoutNV( 7326 static_cast<VkDevice>( m_device ), 7327 static_cast<VkIndirectCommandsLayoutNV>( m_indirectCommandsLayout ), 7328 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7329 } 7330 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 7331 m_indirectCommandsLayout = 7332 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ); 7333 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 7334 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 7335 } 7336 return *this; 7337 } 7338 operator *() const7339 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const VULKAN_HPP_NOEXCEPT 7340 { 7341 return m_indirectCommandsLayout; 7342 } 7343 getDevice() const7344 VULKAN_HPP_NAMESPACE::Device getDevice() const 7345 { 7346 return m_device; 7347 } 7348 getDispatcher() const7349 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7350 { 7351 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7352 return m_dispatcher; 7353 } 7354 7355 private: 7356 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7357 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayout = {}; 7358 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 7359 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7360 }; 7361 7362 class PerformanceConfigurationINTEL 7363 { 7364 public: 7365 using CType = VkPerformanceConfigurationINTEL; 7366 7367 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 7368 VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL; 7369 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7370 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 7371 7372 public: PerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo)7373 PerformanceConfigurationINTEL( 7374 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7375 VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) 7376 : m_device( *device ), m_dispatcher( device.getDispatcher() ) 7377 { 7378 VULKAN_HPP_NAMESPACE::Result result = 7379 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkAcquirePerformanceConfigurationINTEL( 7380 static_cast<VkDevice>( *device ), 7381 reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ), 7382 reinterpret_cast<VkPerformanceConfigurationINTEL *>( &m_configuration ) ) ); 7383 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 7384 { 7385 throwResultException( result, "vkAcquirePerformanceConfigurationINTEL" ); 7386 } 7387 } 7388 PerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPerformanceConfigurationINTEL configuration)7389 PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7390 VkPerformanceConfigurationINTEL configuration ) 7391 : m_device( *device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() ) 7392 {} 7393 PerformanceConfigurationINTEL(std::nullptr_t)7394 PerformanceConfigurationINTEL( std::nullptr_t ) {} 7395 ~PerformanceConfigurationINTEL()7396 ~PerformanceConfigurationINTEL() 7397 { 7398 if ( m_configuration ) 7399 { 7400 getDispatcher()->vkReleasePerformanceConfigurationINTEL( 7401 static_cast<VkDevice>( m_device ), static_cast<VkPerformanceConfigurationINTEL>( m_configuration ) ); 7402 } 7403 } 7404 7405 PerformanceConfigurationINTEL() = delete; 7406 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & ) = delete; PerformanceConfigurationINTEL(PerformanceConfigurationINTEL && rhs)7407 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT 7408 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 7409 , m_configuration( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_configuration, {} ) ) 7410 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7411 {} 7412 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & ) = delete; operator =(PerformanceConfigurationINTEL && rhs)7413 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT 7414 { 7415 if ( this != &rhs ) 7416 { 7417 if ( m_configuration ) 7418 { 7419 getDispatcher()->vkReleasePerformanceConfigurationINTEL( 7420 static_cast<VkDevice>( m_device ), static_cast<VkPerformanceConfigurationINTEL>( m_configuration ) ); 7421 } 7422 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 7423 m_configuration = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_configuration, {} ); 7424 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 7425 } 7426 return *this; 7427 } 7428 operator *() const7429 VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const VULKAN_HPP_NOEXCEPT 7430 { 7431 return m_configuration; 7432 } 7433 getDevice() const7434 VULKAN_HPP_NAMESPACE::Device getDevice() const 7435 { 7436 return m_device; 7437 } 7438 getDispatcher() const7439 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7440 { 7441 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7442 return m_dispatcher; 7443 } 7444 7445 private: 7446 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7447 VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_configuration = {}; 7448 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7449 }; 7450 7451 class PipelineCache 7452 { 7453 public: 7454 using CType = VkPipelineCache; 7455 7456 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 7457 VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache; 7458 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7459 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache; 7460 7461 public: PipelineCache(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7462 PipelineCache( 7463 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7464 VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo, 7465 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7466 : m_device( *device ) 7467 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7468 , m_dispatcher( device.getDispatcher() ) 7469 { 7470 VULKAN_HPP_NAMESPACE::Result result = 7471 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreatePipelineCache( 7472 static_cast<VkDevice>( *device ), 7473 reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ), 7474 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 7475 reinterpret_cast<VkPipelineCache *>( &m_pipelineCache ) ) ); 7476 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 7477 { 7478 throwResultException( result, "vkCreatePipelineCache" ); 7479 } 7480 } 7481 PipelineCache(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPipelineCache pipelineCache,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7482 PipelineCache( 7483 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7484 VkPipelineCache pipelineCache, 7485 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7486 : m_device( *device ) 7487 , m_pipelineCache( pipelineCache ) 7488 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7489 , m_dispatcher( device.getDispatcher() ) 7490 {} 7491 PipelineCache(std::nullptr_t)7492 PipelineCache( std::nullptr_t ) {} 7493 ~PipelineCache()7494 ~PipelineCache() 7495 { 7496 if ( m_pipelineCache ) 7497 { 7498 getDispatcher()->vkDestroyPipelineCache( static_cast<VkDevice>( m_device ), 7499 static_cast<VkPipelineCache>( m_pipelineCache ), 7500 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7501 } 7502 } 7503 7504 PipelineCache() = delete; 7505 PipelineCache( PipelineCache const & ) = delete; PipelineCache(PipelineCache && rhs)7506 PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT 7507 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 7508 , m_pipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) ) 7509 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7510 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7511 {} 7512 PipelineCache & operator=( PipelineCache const & ) = delete; operator =(PipelineCache && rhs)7513 PipelineCache & operator =( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT 7514 { 7515 if ( this != &rhs ) 7516 { 7517 if ( m_pipelineCache ) 7518 { 7519 getDispatcher()->vkDestroyPipelineCache( static_cast<VkDevice>( m_device ), 7520 static_cast<VkPipelineCache>( m_pipelineCache ), 7521 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7522 } 7523 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 7524 m_pipelineCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} ); 7525 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 7526 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 7527 } 7528 return *this; 7529 } 7530 operator *() const7531 VULKAN_HPP_NAMESPACE::PipelineCache const & operator*() const VULKAN_HPP_NOEXCEPT 7532 { 7533 return m_pipelineCache; 7534 } 7535 getDevice() const7536 VULKAN_HPP_NAMESPACE::Device getDevice() const 7537 { 7538 return m_device; 7539 } 7540 getDispatcher() const7541 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7542 { 7543 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7544 return m_dispatcher; 7545 } 7546 7547 //=== VK_VERSION_1_0 === 7548 7549 VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const; 7550 7551 void merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const; 7552 7553 private: 7554 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7555 VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache = {}; 7556 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 7557 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7558 }; 7559 7560 class Pipeline 7561 { 7562 public: 7563 using CType = VkPipeline; 7564 7565 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 7566 VULKAN_HPP_NAMESPACE::ObjectType::ePipeline; 7567 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7568 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline; 7569 7570 public: Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7571 Pipeline( 7572 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7573 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 7574 pipelineCache, 7575 VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo, 7576 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7577 : m_device( *device ) 7578 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7579 , m_dispatcher( device.getDispatcher() ) 7580 { 7581 m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateComputePipelines( 7582 static_cast<VkDevice>( *device ), 7583 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 7584 1, 7585 reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), 7586 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 7587 reinterpret_cast<VkPipeline *>( &m_pipeline ) ) ); 7588 if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 7589 ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 7590 { 7591 throwResultException( m_constructorSuccessCode, "vkCreateComputePipelines" ); 7592 } 7593 } 7594 Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7595 Pipeline( 7596 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7597 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 7598 pipelineCache, 7599 VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo, 7600 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7601 : m_device( *device ) 7602 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7603 , m_dispatcher( device.getDispatcher() ) 7604 { 7605 m_constructorSuccessCode = 7606 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateGraphicsPipelines( 7607 static_cast<VkDevice>( *device ), 7608 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 7609 1, 7610 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ), 7611 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 7612 reinterpret_cast<VkPipeline *>( &m_pipeline ) ) ); 7613 if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 7614 ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 7615 { 7616 throwResultException( m_constructorSuccessCode, "vkCreateGraphicsPipelines" ); 7617 } 7618 } 7619 Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7620 Pipeline( 7621 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7622 VULKAN_HPP_NAMESPACE::Optional< 7623 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 7624 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 7625 pipelineCache, 7626 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo, 7627 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7628 : m_device( *device ) 7629 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7630 , m_dispatcher( device.getDispatcher() ) 7631 { 7632 m_constructorSuccessCode = 7633 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesKHR( 7634 static_cast<VkDevice>( *device ), 7635 deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0, 7636 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 7637 1, 7638 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ), 7639 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 7640 reinterpret_cast<VkPipeline *>( &m_pipeline ) ) ); 7641 if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 7642 ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) && 7643 ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) && 7644 ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 7645 { 7646 throwResultException( m_constructorSuccessCode, "vkCreateRayTracingPipelinesKHR" ); 7647 } 7648 } 7649 Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7650 Pipeline( 7651 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7652 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 7653 pipelineCache, 7654 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo, 7655 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7656 : m_device( *device ) 7657 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7658 , m_dispatcher( device.getDispatcher() ) 7659 { 7660 m_constructorSuccessCode = 7661 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesNV( 7662 static_cast<VkDevice>( *device ), 7663 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 7664 1, 7665 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ), 7666 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 7667 reinterpret_cast<VkPipeline *>( &m_pipeline ) ) ); 7668 if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 7669 ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 7670 { 7671 throwResultException( m_constructorSuccessCode, "vkCreateRayTracingPipelinesNV" ); 7672 } 7673 } 7674 Pipeline(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPipeline pipeline,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr,VULKAN_HPP_NAMESPACE::Result successCode=VULKAN_HPP_NAMESPACE::Result::eSuccess)7675 Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7676 VkPipeline pipeline, 7677 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr, 7678 VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess ) 7679 : m_device( *device ) 7680 , m_pipeline( pipeline ) 7681 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7682 , m_constructorSuccessCode( successCode ) 7683 , m_dispatcher( device.getDispatcher() ) 7684 {} 7685 Pipeline(std::nullptr_t)7686 Pipeline( std::nullptr_t ) {} 7687 ~Pipeline()7688 ~Pipeline() 7689 { 7690 if ( m_pipeline ) 7691 { 7692 getDispatcher()->vkDestroyPipeline( static_cast<VkDevice>( m_device ), 7693 static_cast<VkPipeline>( m_pipeline ), 7694 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7695 } 7696 } 7697 7698 Pipeline() = delete; 7699 Pipeline( Pipeline const & ) = delete; Pipeline(Pipeline && rhs)7700 Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT 7701 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 7702 , m_pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} ) ) 7703 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7704 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7705 {} 7706 Pipeline & operator=( Pipeline const & ) = delete; operator =(Pipeline && rhs)7707 Pipeline & operator =( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT 7708 { 7709 if ( this != &rhs ) 7710 { 7711 if ( m_pipeline ) 7712 { 7713 getDispatcher()->vkDestroyPipeline( static_cast<VkDevice>( m_device ), 7714 static_cast<VkPipeline>( m_pipeline ), 7715 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7716 } 7717 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 7718 m_pipeline = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} ); 7719 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 7720 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 7721 } 7722 return *this; 7723 } 7724 operator *() const7725 VULKAN_HPP_NAMESPACE::Pipeline const & operator*() const VULKAN_HPP_NOEXCEPT 7726 { 7727 return m_pipeline; 7728 } 7729 getConstructorSuccessCode() const7730 VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const 7731 { 7732 return m_constructorSuccessCode; 7733 } 7734 getDevice() const7735 VULKAN_HPP_NAMESPACE::Device getDevice() const 7736 { 7737 return m_device; 7738 } 7739 getDispatcher() const7740 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7741 { 7742 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7743 return m_dispatcher; 7744 } 7745 7746 //=== VK_AMD_shader_info === 7747 7748 VULKAN_HPP_NODISCARD std::vector<uint8_t> 7749 getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, 7750 VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType ) const; 7751 7752 //=== VK_NV_ray_tracing === 7753 7754 template <typename T> 7755 VULKAN_HPP_NODISCARD std::vector<T> 7756 getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; 7757 7758 template <typename T> 7759 VULKAN_HPP_NODISCARD T getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const; 7760 7761 void compileDeferredNV( uint32_t shader ) const; 7762 7763 //=== VK_KHR_ray_tracing_pipeline === 7764 7765 template <typename T> 7766 VULKAN_HPP_NODISCARD std::vector<T> 7767 getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; 7768 7769 template <typename T> 7770 VULKAN_HPP_NODISCARD T getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const; 7771 7772 template <typename T> 7773 VULKAN_HPP_NODISCARD std::vector<T> getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, 7774 uint32_t groupCount, 7775 size_t dataSize ) const; 7776 7777 template <typename T> 7778 VULKAN_HPP_NODISCARD T getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, 7779 uint32_t groupCount ) const; 7780 7781 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getRayTracingShaderGroupStackSizeKHR( 7782 uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT; 7783 7784 private: 7785 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7786 VULKAN_HPP_NAMESPACE::Pipeline m_pipeline = {}; 7787 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 7788 VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode; 7789 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7790 }; 7791 7792 class Pipelines : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> 7793 { 7794 public: Pipelines(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7795 Pipelines( 7796 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7797 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 7798 pipelineCache, 7799 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, 7800 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7801 { 7802 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * dispatcher = device.getDispatcher(); 7803 std::vector<VkPipeline> pipelines( createInfos.size() ); 7804 VULKAN_HPP_NAMESPACE::Result result = 7805 static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkCreateComputePipelines( 7806 static_cast<VkDevice>( *device ), 7807 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 7808 createInfos.size(), 7809 reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), 7810 reinterpret_cast<const VkAllocationCallbacks *>( 7811 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 7812 pipelines.data() ) ); 7813 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || 7814 ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 7815 { 7816 this->reserve( createInfos.size() ); 7817 for ( auto const & pipeline : pipelines ) 7818 { 7819 this->emplace_back( device, pipeline, allocator, result ); 7820 } 7821 } 7822 else 7823 { 7824 throwResultException( result, "vkCreateComputePipelines" ); 7825 } 7826 } 7827 Pipelines(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7828 Pipelines( 7829 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7830 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 7831 pipelineCache, 7832 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, 7833 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7834 { 7835 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * dispatcher = device.getDispatcher(); 7836 std::vector<VkPipeline> pipelines( createInfos.size() ); 7837 VULKAN_HPP_NAMESPACE::Result result = 7838 static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkCreateGraphicsPipelines( 7839 static_cast<VkDevice>( *device ), 7840 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 7841 createInfos.size(), 7842 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), 7843 reinterpret_cast<const VkAllocationCallbacks *>( 7844 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 7845 pipelines.data() ) ); 7846 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || 7847 ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 7848 { 7849 this->reserve( createInfos.size() ); 7850 for ( auto const & pipeline : pipelines ) 7851 { 7852 this->emplace_back( device, pipeline, allocator, result ); 7853 } 7854 } 7855 else 7856 { 7857 throwResultException( result, "vkCreateGraphicsPipelines" ); 7858 } 7859 } 7860 Pipelines(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7861 Pipelines( 7862 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7863 VULKAN_HPP_NAMESPACE::Optional< 7864 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 7865 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 7866 pipelineCache, 7867 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, 7868 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7869 { 7870 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * dispatcher = device.getDispatcher(); 7871 std::vector<VkPipeline> pipelines( createInfos.size() ); 7872 VULKAN_HPP_NAMESPACE::Result result = 7873 static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkCreateRayTracingPipelinesKHR( 7874 static_cast<VkDevice>( *device ), 7875 deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0, 7876 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 7877 createInfos.size(), 7878 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), 7879 reinterpret_cast<const VkAllocationCallbacks *>( 7880 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 7881 pipelines.data() ) ); 7882 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || 7883 ( result == VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) || 7884 ( result == VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) || 7885 ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 7886 { 7887 this->reserve( createInfos.size() ); 7888 for ( auto const & pipeline : pipelines ) 7889 { 7890 this->emplace_back( device, pipeline, allocator, result ); 7891 } 7892 } 7893 else 7894 { 7895 throwResultException( result, "vkCreateRayTracingPipelinesKHR" ); 7896 } 7897 } 7898 Pipelines(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7899 Pipelines( 7900 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7901 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 7902 pipelineCache, 7903 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, 7904 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7905 { 7906 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * dispatcher = device.getDispatcher(); 7907 std::vector<VkPipeline> pipelines( createInfos.size() ); 7908 VULKAN_HPP_NAMESPACE::Result result = 7909 static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkCreateRayTracingPipelinesNV( 7910 static_cast<VkDevice>( *device ), 7911 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 7912 createInfos.size(), 7913 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), 7914 reinterpret_cast<const VkAllocationCallbacks *>( 7915 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 7916 pipelines.data() ) ); 7917 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) || 7918 ( result == VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 7919 { 7920 this->reserve( createInfos.size() ); 7921 for ( auto const & pipeline : pipelines ) 7922 { 7923 this->emplace_back( device, pipeline, allocator, result ); 7924 } 7925 } 7926 else 7927 { 7928 throwResultException( result, "vkCreateRayTracingPipelinesNV" ); 7929 } 7930 } 7931 7932 Pipelines() = delete; 7933 Pipelines( Pipelines const & ) = delete; 7934 Pipelines( Pipelines && rhs ) = default; 7935 Pipelines & operator=( Pipelines const & ) = delete; 7936 Pipelines & operator=( Pipelines && rhs ) = default; 7937 }; 7938 7939 class PipelineLayout 7940 { 7941 public: 7942 using CType = VkPipelineLayout; 7943 7944 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 7945 VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout; 7946 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7947 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout; 7948 7949 public: PipelineLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7950 PipelineLayout( 7951 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7952 VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo, 7953 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7954 : m_device( *device ) 7955 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7956 , m_dispatcher( device.getDispatcher() ) 7957 { 7958 VULKAN_HPP_NAMESPACE::Result result = 7959 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreatePipelineLayout( 7960 static_cast<VkDevice>( *device ), 7961 reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ), 7962 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 7963 reinterpret_cast<VkPipelineLayout *>( &m_pipelineLayout ) ) ); 7964 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 7965 { 7966 throwResultException( result, "vkCreatePipelineLayout" ); 7967 } 7968 } 7969 PipelineLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPipelineLayout pipelineLayout,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7970 PipelineLayout( 7971 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7972 VkPipelineLayout pipelineLayout, 7973 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7974 : m_device( *device ) 7975 , m_pipelineLayout( pipelineLayout ) 7976 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7977 , m_dispatcher( device.getDispatcher() ) 7978 {} 7979 PipelineLayout(std::nullptr_t)7980 PipelineLayout( std::nullptr_t ) {} 7981 ~PipelineLayout()7982 ~PipelineLayout() 7983 { 7984 if ( m_pipelineLayout ) 7985 { 7986 getDispatcher()->vkDestroyPipelineLayout( static_cast<VkDevice>( m_device ), 7987 static_cast<VkPipelineLayout>( m_pipelineLayout ), 7988 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7989 } 7990 } 7991 7992 PipelineLayout() = delete; 7993 PipelineLayout( PipelineLayout const & ) = delete; PipelineLayout(PipelineLayout && rhs)7994 PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT 7995 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 7996 , m_pipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) ) 7997 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7998 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7999 {} 8000 PipelineLayout & operator=( PipelineLayout const & ) = delete; operator =(PipelineLayout && rhs)8001 PipelineLayout & operator =( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT 8002 { 8003 if ( this != &rhs ) 8004 { 8005 if ( m_pipelineLayout ) 8006 { 8007 getDispatcher()->vkDestroyPipelineLayout( static_cast<VkDevice>( m_device ), 8008 static_cast<VkPipelineLayout>( m_pipelineLayout ), 8009 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8010 } 8011 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 8012 m_pipelineLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ); 8013 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 8014 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 8015 } 8016 return *this; 8017 } 8018 operator *() const8019 VULKAN_HPP_NAMESPACE::PipelineLayout const & operator*() const VULKAN_HPP_NOEXCEPT 8020 { 8021 return m_pipelineLayout; 8022 } 8023 getDevice() const8024 VULKAN_HPP_NAMESPACE::Device getDevice() const 8025 { 8026 return m_device; 8027 } 8028 getDispatcher() const8029 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8030 { 8031 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8032 return m_dispatcher; 8033 } 8034 8035 private: 8036 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8037 VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout = {}; 8038 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 8039 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8040 }; 8041 8042 class PrivateDataSlotEXT 8043 { 8044 public: 8045 using CType = VkPrivateDataSlotEXT; 8046 8047 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 8048 VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT; 8049 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8050 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 8051 8052 public: PrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8053 PrivateDataSlotEXT( 8054 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8055 VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & createInfo, 8056 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8057 : m_device( *device ) 8058 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8059 , m_dispatcher( device.getDispatcher() ) 8060 { 8061 VULKAN_HPP_NAMESPACE::Result result = 8062 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreatePrivateDataSlotEXT( 8063 static_cast<VkDevice>( *device ), 8064 reinterpret_cast<const VkPrivateDataSlotCreateInfoEXT *>( &createInfo ), 8065 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8066 reinterpret_cast<VkPrivateDataSlotEXT *>( &m_privateDataSlot ) ) ); 8067 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8068 { 8069 throwResultException( result, "vkCreatePrivateDataSlotEXT" ); 8070 } 8071 } 8072 PrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPrivateDataSlotEXT privateDataSlot,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8073 PrivateDataSlotEXT( 8074 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8075 VkPrivateDataSlotEXT privateDataSlot, 8076 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8077 : m_device( *device ) 8078 , m_privateDataSlot( privateDataSlot ) 8079 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8080 , m_dispatcher( device.getDispatcher() ) 8081 {} 8082 PrivateDataSlotEXT(std::nullptr_t)8083 PrivateDataSlotEXT( std::nullptr_t ) {} 8084 ~PrivateDataSlotEXT()8085 ~PrivateDataSlotEXT() 8086 { 8087 if ( m_privateDataSlot ) 8088 { 8089 getDispatcher()->vkDestroyPrivateDataSlotEXT( 8090 static_cast<VkDevice>( m_device ), 8091 static_cast<VkPrivateDataSlotEXT>( m_privateDataSlot ), 8092 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8093 } 8094 } 8095 8096 PrivateDataSlotEXT() = delete; 8097 PrivateDataSlotEXT( PrivateDataSlotEXT const & ) = delete; PrivateDataSlotEXT(PrivateDataSlotEXT && rhs)8098 PrivateDataSlotEXT( PrivateDataSlotEXT && rhs ) VULKAN_HPP_NOEXCEPT 8099 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 8100 , m_privateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) ) 8101 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8102 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8103 {} 8104 PrivateDataSlotEXT & operator=( PrivateDataSlotEXT const & ) = delete; operator =(PrivateDataSlotEXT && rhs)8105 PrivateDataSlotEXT & operator =( PrivateDataSlotEXT && rhs ) VULKAN_HPP_NOEXCEPT 8106 { 8107 if ( this != &rhs ) 8108 { 8109 if ( m_privateDataSlot ) 8110 { 8111 getDispatcher()->vkDestroyPrivateDataSlotEXT( 8112 static_cast<VkDevice>( m_device ), 8113 static_cast<VkPrivateDataSlotEXT>( m_privateDataSlot ), 8114 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8115 } 8116 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 8117 m_privateDataSlot = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ); 8118 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 8119 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 8120 } 8121 return *this; 8122 } 8123 operator *() const8124 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & operator*() const VULKAN_HPP_NOEXCEPT 8125 { 8126 return m_privateDataSlot; 8127 } 8128 getDevice() const8129 VULKAN_HPP_NAMESPACE::Device getDevice() const 8130 { 8131 return m_device; 8132 } 8133 getDispatcher() const8134 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8135 { 8136 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8137 return m_dispatcher; 8138 } 8139 8140 private: 8141 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8142 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT m_privateDataSlot = {}; 8143 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 8144 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8145 }; 8146 8147 class QueryPool 8148 { 8149 public: 8150 using CType = VkQueryPool; 8151 8152 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 8153 VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool; 8154 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8155 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool; 8156 8157 public: QueryPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8158 QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8159 VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo, 8160 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8161 : m_device( *device ) 8162 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8163 , m_dispatcher( device.getDispatcher() ) 8164 { 8165 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 8166 device.getDispatcher()->vkCreateQueryPool( static_cast<VkDevice>( *device ), 8167 reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ), 8168 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8169 reinterpret_cast<VkQueryPool *>( &m_queryPool ) ) ); 8170 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8171 { 8172 throwResultException( result, "vkCreateQueryPool" ); 8173 } 8174 } 8175 QueryPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkQueryPool queryPool,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8176 QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8177 VkQueryPool queryPool, 8178 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8179 : m_device( *device ) 8180 , m_queryPool( queryPool ) 8181 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8182 , m_dispatcher( device.getDispatcher() ) 8183 {} 8184 QueryPool(std::nullptr_t)8185 QueryPool( std::nullptr_t ) {} 8186 ~QueryPool()8187 ~QueryPool() 8188 { 8189 if ( m_queryPool ) 8190 { 8191 getDispatcher()->vkDestroyQueryPool( static_cast<VkDevice>( m_device ), 8192 static_cast<VkQueryPool>( m_queryPool ), 8193 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8194 } 8195 } 8196 8197 QueryPool() = delete; 8198 QueryPool( QueryPool const & ) = delete; QueryPool(QueryPool && rhs)8199 QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT 8200 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 8201 , m_queryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} ) ) 8202 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8203 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8204 {} 8205 QueryPool & operator=( QueryPool const & ) = delete; operator =(QueryPool && rhs)8206 QueryPool & operator =( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT 8207 { 8208 if ( this != &rhs ) 8209 { 8210 if ( m_queryPool ) 8211 { 8212 getDispatcher()->vkDestroyQueryPool( static_cast<VkDevice>( m_device ), 8213 static_cast<VkQueryPool>( m_queryPool ), 8214 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8215 } 8216 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 8217 m_queryPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} ); 8218 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 8219 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 8220 } 8221 return *this; 8222 } 8223 operator *() const8224 VULKAN_HPP_NAMESPACE::QueryPool const & operator*() const VULKAN_HPP_NOEXCEPT 8225 { 8226 return m_queryPool; 8227 } 8228 getDevice() const8229 VULKAN_HPP_NAMESPACE::Device getDevice() const 8230 { 8231 return m_device; 8232 } 8233 getDispatcher() const8234 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8235 { 8236 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8237 return m_dispatcher; 8238 } 8239 8240 //=== VK_VERSION_1_0 === 8241 8242 template <typename T> 8243 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>> 8244 getResults( uint32_t firstQuery, 8245 uint32_t queryCount, 8246 size_t dataSize, 8247 VULKAN_HPP_NAMESPACE::DeviceSize stride, 8248 VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 8249 8250 template <typename T> 8251 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T> 8252 getResult( uint32_t firstQuery, 8253 uint32_t queryCount, 8254 VULKAN_HPP_NAMESPACE::DeviceSize stride, 8255 VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 8256 8257 //=== VK_VERSION_1_2 === 8258 8259 void reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; 8260 8261 //=== VK_EXT_host_query_reset === 8262 8263 void resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; 8264 8265 private: 8266 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8267 VULKAN_HPP_NAMESPACE::QueryPool m_queryPool = {}; 8268 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 8269 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8270 }; 8271 8272 class Queue 8273 { 8274 public: 8275 using CType = VkQueue; 8276 8277 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 8278 VULKAN_HPP_NAMESPACE::ObjectType::eQueue; 8279 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8280 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue; 8281 8282 public: Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,uint32_t queueFamilyIndex,uint32_t queueIndex)8283 Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8284 uint32_t queueFamilyIndex, 8285 uint32_t queueIndex ) 8286 : m_dispatcher( device.getDispatcher() ) 8287 { 8288 getDispatcher()->vkGetDeviceQueue( 8289 static_cast<VkDevice>( *device ), queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &m_queue ) ); 8290 } 8291 Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo)8292 Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8293 VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) 8294 : m_dispatcher( device.getDispatcher() ) 8295 { 8296 getDispatcher()->vkGetDeviceQueue2( static_cast<VkDevice>( *device ), 8297 reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), 8298 reinterpret_cast<VkQueue *>( &m_queue ) ); 8299 } 8300 Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkQueue queue)8301 Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkQueue queue ) 8302 : m_queue( queue ), m_dispatcher( device.getDispatcher() ) 8303 {} 8304 Queue(std::nullptr_t)8305 Queue( std::nullptr_t ) {} 8306 8307 Queue() = delete; 8308 Queue( Queue const & ) = delete; Queue(Queue && rhs)8309 Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT 8310 : m_queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ) ) 8311 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8312 {} 8313 Queue & operator=( Queue const & ) = delete; operator =(Queue && rhs)8314 Queue & operator =( Queue && rhs ) VULKAN_HPP_NOEXCEPT 8315 { 8316 if ( this != &rhs ) 8317 { 8318 m_queue = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ); 8319 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 8320 } 8321 return *this; 8322 } 8323 operator *() const8324 VULKAN_HPP_NAMESPACE::Queue const & operator*() const VULKAN_HPP_NOEXCEPT 8325 { 8326 return m_queue; 8327 } 8328 getDispatcher() const8329 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8330 { 8331 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8332 return m_dispatcher; 8333 } 8334 8335 //=== VK_VERSION_1_0 === 8336 8337 void submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits, 8338 VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 8339 8340 void waitIdle() const; 8341 8342 void bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo, 8343 VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 8344 8345 //=== VK_KHR_swapchain === 8346 8347 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result 8348 presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo ) const; 8349 8350 //=== VK_EXT_debug_utils === 8351 8352 void 8353 beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; 8354 8355 void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; 8356 8357 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const 8358 VULKAN_HPP_NOEXCEPT; 8359 8360 //=== VK_NV_device_diagnostic_checkpoints === 8361 8362 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> 8363 getCheckpointDataNV() const VULKAN_HPP_NOEXCEPT; 8364 8365 //=== VK_INTEL_performance_query === 8366 8367 void setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const; 8368 8369 //=== VK_KHR_synchronization2 === 8370 8371 void submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits, 8372 VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 8373 8374 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> 8375 getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT; 8376 8377 private: 8378 VULKAN_HPP_NAMESPACE::Queue m_queue = {}; 8379 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8380 }; 8381 8382 class RenderPass 8383 { 8384 public: 8385 using CType = VkRenderPass; 8386 8387 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 8388 VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass; 8389 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8390 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass; 8391 8392 public: RenderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8393 RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8394 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo, 8395 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8396 : m_device( *device ) 8397 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8398 , m_dispatcher( device.getDispatcher() ) 8399 { 8400 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 8401 device.getDispatcher()->vkCreateRenderPass( static_cast<VkDevice>( *device ), 8402 reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ), 8403 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8404 reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) ); 8405 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8406 { 8407 throwResultException( result, "vkCreateRenderPass" ); 8408 } 8409 } 8410 RenderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8411 RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8412 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 8413 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8414 : m_device( *device ) 8415 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8416 , m_dispatcher( device.getDispatcher() ) 8417 { 8418 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 8419 device.getDispatcher()->vkCreateRenderPass2( static_cast<VkDevice>( *device ), 8420 reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ), 8421 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8422 reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) ); 8423 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8424 { 8425 throwResultException( result, "vkCreateRenderPass2" ); 8426 } 8427 } 8428 RenderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkRenderPass renderPass,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8429 RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8430 VkRenderPass renderPass, 8431 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8432 : m_device( *device ) 8433 , m_renderPass( renderPass ) 8434 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8435 , m_dispatcher( device.getDispatcher() ) 8436 {} 8437 RenderPass(std::nullptr_t)8438 RenderPass( std::nullptr_t ) {} 8439 ~RenderPass()8440 ~RenderPass() 8441 { 8442 if ( m_renderPass ) 8443 { 8444 getDispatcher()->vkDestroyRenderPass( static_cast<VkDevice>( m_device ), 8445 static_cast<VkRenderPass>( m_renderPass ), 8446 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8447 } 8448 } 8449 8450 RenderPass() = delete; 8451 RenderPass( RenderPass const & ) = delete; RenderPass(RenderPass && rhs)8452 RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT 8453 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 8454 , m_renderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} ) ) 8455 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8456 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8457 {} 8458 RenderPass & operator=( RenderPass const & ) = delete; operator =(RenderPass && rhs)8459 RenderPass & operator =( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT 8460 { 8461 if ( this != &rhs ) 8462 { 8463 if ( m_renderPass ) 8464 { 8465 getDispatcher()->vkDestroyRenderPass( static_cast<VkDevice>( m_device ), 8466 static_cast<VkRenderPass>( m_renderPass ), 8467 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8468 } 8469 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 8470 m_renderPass = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} ); 8471 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 8472 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 8473 } 8474 return *this; 8475 } 8476 operator *() const8477 VULKAN_HPP_NAMESPACE::RenderPass const & operator*() const VULKAN_HPP_NOEXCEPT 8478 { 8479 return m_renderPass; 8480 } 8481 getDevice() const8482 VULKAN_HPP_NAMESPACE::Device getDevice() const 8483 { 8484 return m_device; 8485 } 8486 getDispatcher() const8487 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8488 { 8489 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8490 return m_dispatcher; 8491 } 8492 8493 //=== VK_VERSION_1_0 === 8494 8495 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT; 8496 8497 //=== VK_HUAWEI_subpass_shading === 8498 8499 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D> 8500 getSubpassShadingMaxWorkgroupSizeHUAWEI() const; 8501 8502 private: 8503 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8504 VULKAN_HPP_NAMESPACE::RenderPass m_renderPass = {}; 8505 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 8506 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8507 }; 8508 8509 class Sampler 8510 { 8511 public: 8512 using CType = VkSampler; 8513 8514 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 8515 VULKAN_HPP_NAMESPACE::ObjectType::eSampler; 8516 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8517 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler; 8518 8519 public: Sampler(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8520 Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8521 VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo, 8522 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8523 : m_device( *device ) 8524 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8525 , m_dispatcher( device.getDispatcher() ) 8526 { 8527 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 8528 device.getDispatcher()->vkCreateSampler( static_cast<VkDevice>( *device ), 8529 reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ), 8530 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8531 reinterpret_cast<VkSampler *>( &m_sampler ) ) ); 8532 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8533 { 8534 throwResultException( result, "vkCreateSampler" ); 8535 } 8536 } 8537 Sampler(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkSampler sampler,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8538 Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8539 VkSampler sampler, 8540 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8541 : m_device( *device ) 8542 , m_sampler( sampler ) 8543 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8544 , m_dispatcher( device.getDispatcher() ) 8545 {} 8546 Sampler(std::nullptr_t)8547 Sampler( std::nullptr_t ) {} 8548 ~Sampler()8549 ~Sampler() 8550 { 8551 if ( m_sampler ) 8552 { 8553 getDispatcher()->vkDestroySampler( static_cast<VkDevice>( m_device ), 8554 static_cast<VkSampler>( m_sampler ), 8555 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8556 } 8557 } 8558 8559 Sampler() = delete; 8560 Sampler( Sampler const & ) = delete; Sampler(Sampler && rhs)8561 Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT 8562 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 8563 , m_sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} ) ) 8564 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8565 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8566 {} 8567 Sampler & operator=( Sampler const & ) = delete; operator =(Sampler && rhs)8568 Sampler & operator =( Sampler && rhs ) VULKAN_HPP_NOEXCEPT 8569 { 8570 if ( this != &rhs ) 8571 { 8572 if ( m_sampler ) 8573 { 8574 getDispatcher()->vkDestroySampler( static_cast<VkDevice>( m_device ), 8575 static_cast<VkSampler>( m_sampler ), 8576 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8577 } 8578 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 8579 m_sampler = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} ); 8580 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 8581 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 8582 } 8583 return *this; 8584 } 8585 operator *() const8586 VULKAN_HPP_NAMESPACE::Sampler const & operator*() const VULKAN_HPP_NOEXCEPT 8587 { 8588 return m_sampler; 8589 } 8590 getDevice() const8591 VULKAN_HPP_NAMESPACE::Device getDevice() const 8592 { 8593 return m_device; 8594 } 8595 getDispatcher() const8596 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8597 { 8598 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8599 return m_dispatcher; 8600 } 8601 8602 private: 8603 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8604 VULKAN_HPP_NAMESPACE::Sampler m_sampler = {}; 8605 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 8606 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8607 }; 8608 8609 class SamplerYcbcrConversion 8610 { 8611 public: 8612 using CType = VkSamplerYcbcrConversion; 8613 8614 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 8615 VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion; 8616 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8617 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion; 8618 8619 public: SamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8620 SamplerYcbcrConversion( 8621 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8622 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 8623 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8624 : m_device( *device ) 8625 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8626 , m_dispatcher( device.getDispatcher() ) 8627 { 8628 VULKAN_HPP_NAMESPACE::Result result = 8629 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateSamplerYcbcrConversion( 8630 static_cast<VkDevice>( *device ), 8631 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ), 8632 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8633 reinterpret_cast<VkSamplerYcbcrConversion *>( &m_ycbcrConversion ) ) ); 8634 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8635 { 8636 throwResultException( result, "vkCreateSamplerYcbcrConversion" ); 8637 } 8638 } 8639 SamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkSamplerYcbcrConversion ycbcrConversion,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8640 SamplerYcbcrConversion( 8641 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8642 VkSamplerYcbcrConversion ycbcrConversion, 8643 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8644 : m_device( *device ) 8645 , m_ycbcrConversion( ycbcrConversion ) 8646 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8647 , m_dispatcher( device.getDispatcher() ) 8648 {} 8649 SamplerYcbcrConversion(std::nullptr_t)8650 SamplerYcbcrConversion( std::nullptr_t ) {} 8651 ~SamplerYcbcrConversion()8652 ~SamplerYcbcrConversion() 8653 { 8654 if ( m_ycbcrConversion ) 8655 { 8656 getDispatcher()->vkDestroySamplerYcbcrConversion( 8657 static_cast<VkDevice>( m_device ), 8658 static_cast<VkSamplerYcbcrConversion>( m_ycbcrConversion ), 8659 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8660 } 8661 } 8662 8663 SamplerYcbcrConversion() = delete; 8664 SamplerYcbcrConversion( SamplerYcbcrConversion const & ) = delete; SamplerYcbcrConversion(SamplerYcbcrConversion && rhs)8665 SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT 8666 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 8667 , m_ycbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ) ) 8668 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8669 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8670 {} 8671 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & ) = delete; operator =(SamplerYcbcrConversion && rhs)8672 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT 8673 { 8674 if ( this != &rhs ) 8675 { 8676 if ( m_ycbcrConversion ) 8677 { 8678 getDispatcher()->vkDestroySamplerYcbcrConversion( 8679 static_cast<VkDevice>( m_device ), 8680 static_cast<VkSamplerYcbcrConversion>( m_ycbcrConversion ), 8681 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8682 } 8683 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 8684 m_ycbcrConversion = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ); 8685 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 8686 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 8687 } 8688 return *this; 8689 } 8690 operator *() const8691 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & operator*() const VULKAN_HPP_NOEXCEPT 8692 { 8693 return m_ycbcrConversion; 8694 } 8695 getDevice() const8696 VULKAN_HPP_NAMESPACE::Device getDevice() const 8697 { 8698 return m_device; 8699 } 8700 getDispatcher() const8701 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8702 { 8703 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8704 return m_dispatcher; 8705 } 8706 8707 private: 8708 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8709 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_ycbcrConversion = {}; 8710 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 8711 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8712 }; 8713 8714 class Semaphore 8715 { 8716 public: 8717 using CType = VkSemaphore; 8718 8719 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 8720 VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore; 8721 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8722 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore; 8723 8724 public: Semaphore(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8725 Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8726 VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo, 8727 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8728 : m_device( *device ) 8729 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8730 , m_dispatcher( device.getDispatcher() ) 8731 { 8732 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 8733 device.getDispatcher()->vkCreateSemaphore( static_cast<VkDevice>( *device ), 8734 reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ), 8735 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8736 reinterpret_cast<VkSemaphore *>( &m_semaphore ) ) ); 8737 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8738 { 8739 throwResultException( result, "vkCreateSemaphore" ); 8740 } 8741 } 8742 Semaphore(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkSemaphore semaphore,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8743 Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8744 VkSemaphore semaphore, 8745 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8746 : m_device( *device ) 8747 , m_semaphore( semaphore ) 8748 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8749 , m_dispatcher( device.getDispatcher() ) 8750 {} 8751 Semaphore(std::nullptr_t)8752 Semaphore( std::nullptr_t ) {} 8753 ~Semaphore()8754 ~Semaphore() 8755 { 8756 if ( m_semaphore ) 8757 { 8758 getDispatcher()->vkDestroySemaphore( static_cast<VkDevice>( m_device ), 8759 static_cast<VkSemaphore>( m_semaphore ), 8760 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8761 } 8762 } 8763 8764 Semaphore() = delete; 8765 Semaphore( Semaphore const & ) = delete; Semaphore(Semaphore && rhs)8766 Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT 8767 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 8768 , m_semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} ) ) 8769 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8770 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8771 {} 8772 Semaphore & operator=( Semaphore const & ) = delete; operator =(Semaphore && rhs)8773 Semaphore & operator =( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT 8774 { 8775 if ( this != &rhs ) 8776 { 8777 if ( m_semaphore ) 8778 { 8779 getDispatcher()->vkDestroySemaphore( static_cast<VkDevice>( m_device ), 8780 static_cast<VkSemaphore>( m_semaphore ), 8781 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8782 } 8783 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 8784 m_semaphore = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} ); 8785 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 8786 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 8787 } 8788 return *this; 8789 } 8790 operator *() const8791 VULKAN_HPP_NAMESPACE::Semaphore const & operator*() const VULKAN_HPP_NOEXCEPT 8792 { 8793 return m_semaphore; 8794 } 8795 getDevice() const8796 VULKAN_HPP_NAMESPACE::Device getDevice() const 8797 { 8798 return m_device; 8799 } 8800 getDispatcher() const8801 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8802 { 8803 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8804 return m_dispatcher; 8805 } 8806 8807 //=== VK_VERSION_1_2 === 8808 8809 VULKAN_HPP_NODISCARD uint64_t getCounterValue() const; 8810 8811 //=== VK_KHR_timeline_semaphore === 8812 8813 VULKAN_HPP_NODISCARD uint64_t getCounterValueKHR() const; 8814 8815 private: 8816 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8817 VULKAN_HPP_NAMESPACE::Semaphore m_semaphore = {}; 8818 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 8819 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8820 }; 8821 8822 class ShaderModule 8823 { 8824 public: 8825 using CType = VkShaderModule; 8826 8827 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 8828 VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule; 8829 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8830 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule; 8831 8832 public: ShaderModule(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8833 ShaderModule( 8834 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8835 VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo, 8836 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8837 : m_device( *device ) 8838 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8839 , m_dispatcher( device.getDispatcher() ) 8840 { 8841 VULKAN_HPP_NAMESPACE::Result result = 8842 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateShaderModule( 8843 static_cast<VkDevice>( *device ), 8844 reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ), 8845 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8846 reinterpret_cast<VkShaderModule *>( &m_shaderModule ) ) ); 8847 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8848 { 8849 throwResultException( result, "vkCreateShaderModule" ); 8850 } 8851 } 8852 ShaderModule(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkShaderModule shaderModule,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8853 ShaderModule( 8854 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8855 VkShaderModule shaderModule, 8856 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8857 : m_device( *device ) 8858 , m_shaderModule( shaderModule ) 8859 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8860 , m_dispatcher( device.getDispatcher() ) 8861 {} 8862 ShaderModule(std::nullptr_t)8863 ShaderModule( std::nullptr_t ) {} 8864 ~ShaderModule()8865 ~ShaderModule() 8866 { 8867 if ( m_shaderModule ) 8868 { 8869 getDispatcher()->vkDestroyShaderModule( static_cast<VkDevice>( m_device ), 8870 static_cast<VkShaderModule>( m_shaderModule ), 8871 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8872 } 8873 } 8874 8875 ShaderModule() = delete; 8876 ShaderModule( ShaderModule const & ) = delete; ShaderModule(ShaderModule && rhs)8877 ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT 8878 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 8879 , m_shaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} ) ) 8880 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8881 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8882 {} 8883 ShaderModule & operator=( ShaderModule const & ) = delete; operator =(ShaderModule && rhs)8884 ShaderModule & operator =( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT 8885 { 8886 if ( this != &rhs ) 8887 { 8888 if ( m_shaderModule ) 8889 { 8890 getDispatcher()->vkDestroyShaderModule( static_cast<VkDevice>( m_device ), 8891 static_cast<VkShaderModule>( m_shaderModule ), 8892 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8893 } 8894 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 8895 m_shaderModule = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} ); 8896 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 8897 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 8898 } 8899 return *this; 8900 } 8901 operator *() const8902 VULKAN_HPP_NAMESPACE::ShaderModule const & operator*() const VULKAN_HPP_NOEXCEPT 8903 { 8904 return m_shaderModule; 8905 } 8906 getDevice() const8907 VULKAN_HPP_NAMESPACE::Device getDevice() const 8908 { 8909 return m_device; 8910 } 8911 getDispatcher() const8912 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8913 { 8914 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8915 return m_dispatcher; 8916 } 8917 8918 private: 8919 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8920 VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule = {}; 8921 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 8922 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8923 }; 8924 8925 class SurfaceKHR 8926 { 8927 public: 8928 using CType = VkSurfaceKHR; 8929 8930 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 8931 VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR; 8932 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8933 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR; 8934 8935 public: 8936 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8937 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 8938 VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo, 8939 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8940 : m_instance( *instance ) 8941 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8942 , m_dispatcher( instance.getDispatcher() ) 8943 { 8944 VULKAN_HPP_NAMESPACE::Result result = 8945 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateAndroidSurfaceKHR( 8946 static_cast<VkInstance>( *instance ), 8947 reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ), 8948 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8949 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 8950 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8951 { 8952 throwResultException( result, "vkCreateAndroidSurfaceKHR" ); 8953 } 8954 } 8955 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8956 8957 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8958 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 8959 VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo, 8960 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8961 : m_instance( *instance ) 8962 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8963 , m_dispatcher( instance.getDispatcher() ) 8964 { 8965 VULKAN_HPP_NAMESPACE::Result result = 8966 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateDirectFBSurfaceEXT( 8967 static_cast<VkInstance>( *instance ), 8968 reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ), 8969 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8970 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 8971 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8972 { 8973 throwResultException( result, "vkCreateDirectFBSurfaceEXT" ); 8974 } 8975 } 8976 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 8977 SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8978 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 8979 VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo, 8980 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8981 : m_instance( *instance ) 8982 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8983 , m_dispatcher( instance.getDispatcher() ) 8984 { 8985 VULKAN_HPP_NAMESPACE::Result result = 8986 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateDisplayPlaneSurfaceKHR( 8987 static_cast<VkInstance>( *instance ), 8988 reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ), 8989 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 8990 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 8991 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 8992 { 8993 throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" ); 8994 } 8995 } 8996 SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8997 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 8998 VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo, 8999 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9000 : m_instance( *instance ) 9001 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9002 , m_dispatcher( instance.getDispatcher() ) 9003 { 9004 VULKAN_HPP_NAMESPACE::Result result = 9005 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateHeadlessSurfaceEXT( 9006 static_cast<VkInstance>( *instance ), 9007 reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ), 9008 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9009 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9010 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9011 { 9012 throwResultException( result, "vkCreateHeadlessSurfaceEXT" ); 9013 } 9014 } 9015 9016 # if defined( VK_USE_PLATFORM_IOS_MVK ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9017 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9018 VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo, 9019 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9020 : m_instance( *instance ) 9021 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9022 , m_dispatcher( instance.getDispatcher() ) 9023 { 9024 VULKAN_HPP_NAMESPACE::Result result = 9025 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateIOSSurfaceMVK( 9026 static_cast<VkInstance>( *instance ), 9027 reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ), 9028 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9029 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9030 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9031 { 9032 throwResultException( result, "vkCreateIOSSurfaceMVK" ); 9033 } 9034 } 9035 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 9036 9037 # if defined( VK_USE_PLATFORM_FUCHSIA ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9038 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9039 VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, 9040 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9041 : m_instance( *instance ) 9042 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9043 , m_dispatcher( instance.getDispatcher() ) 9044 { 9045 VULKAN_HPP_NAMESPACE::Result result = 9046 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA( 9047 static_cast<VkInstance>( *instance ), 9048 reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ), 9049 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9050 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9051 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9052 { 9053 throwResultException( result, "vkCreateImagePipeSurfaceFUCHSIA" ); 9054 } 9055 } 9056 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 9057 9058 # if defined( VK_USE_PLATFORM_MACOS_MVK ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9059 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9060 VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo, 9061 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9062 : m_instance( *instance ) 9063 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9064 , m_dispatcher( instance.getDispatcher() ) 9065 { 9066 VULKAN_HPP_NAMESPACE::Result result = 9067 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateMacOSSurfaceMVK( 9068 static_cast<VkInstance>( *instance ), 9069 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ), 9070 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9071 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9072 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9073 { 9074 throwResultException( result, "vkCreateMacOSSurfaceMVK" ); 9075 } 9076 } 9077 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 9078 9079 # if defined( VK_USE_PLATFORM_METAL_EXT ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9080 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9081 VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo, 9082 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9083 : m_instance( *instance ) 9084 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9085 , m_dispatcher( instance.getDispatcher() ) 9086 { 9087 VULKAN_HPP_NAMESPACE::Result result = 9088 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateMetalSurfaceEXT( 9089 static_cast<VkInstance>( *instance ), 9090 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ), 9091 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9092 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9093 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9094 { 9095 throwResultException( result, "vkCreateMetalSurfaceEXT" ); 9096 } 9097 } 9098 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 9099 9100 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9101 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9102 VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, 9103 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9104 : m_instance( *instance ) 9105 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9106 , m_dispatcher( instance.getDispatcher() ) 9107 { 9108 VULKAN_HPP_NAMESPACE::Result result = 9109 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateScreenSurfaceQNX( 9110 static_cast<VkInstance>( *instance ), 9111 reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ), 9112 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9113 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9114 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9115 { 9116 throwResultException( result, "vkCreateScreenSurfaceQNX" ); 9117 } 9118 } 9119 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 9120 9121 # if defined( VK_USE_PLATFORM_GGP ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9122 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9123 VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, 9124 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9125 : m_instance( *instance ) 9126 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9127 , m_dispatcher( instance.getDispatcher() ) 9128 { 9129 VULKAN_HPP_NAMESPACE::Result result = 9130 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateStreamDescriptorSurfaceGGP( 9131 static_cast<VkInstance>( *instance ), 9132 reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ), 9133 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9134 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9135 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9136 { 9137 throwResultException( result, "vkCreateStreamDescriptorSurfaceGGP" ); 9138 } 9139 } 9140 # endif /*VK_USE_PLATFORM_GGP*/ 9141 9142 # if defined( VK_USE_PLATFORM_VI_NN ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9143 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9144 VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, 9145 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9146 : m_instance( *instance ) 9147 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9148 , m_dispatcher( instance.getDispatcher() ) 9149 { 9150 VULKAN_HPP_NAMESPACE::Result result = 9151 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateViSurfaceNN( 9152 static_cast<VkInstance>( *instance ), 9153 reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ), 9154 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9155 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9156 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9157 { 9158 throwResultException( result, "vkCreateViSurfaceNN" ); 9159 } 9160 } 9161 # endif /*VK_USE_PLATFORM_VI_NN*/ 9162 9163 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9164 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9165 VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo, 9166 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9167 : m_instance( *instance ) 9168 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9169 , m_dispatcher( instance.getDispatcher() ) 9170 { 9171 VULKAN_HPP_NAMESPACE::Result result = 9172 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateWaylandSurfaceKHR( 9173 static_cast<VkInstance>( *instance ), 9174 reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ), 9175 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9176 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9177 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9178 { 9179 throwResultException( result, "vkCreateWaylandSurfaceKHR" ); 9180 } 9181 } 9182 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 9183 9184 # if defined( VK_USE_PLATFORM_WIN32_KHR ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9185 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9186 VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo, 9187 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9188 : m_instance( *instance ) 9189 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9190 , m_dispatcher( instance.getDispatcher() ) 9191 { 9192 VULKAN_HPP_NAMESPACE::Result result = 9193 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateWin32SurfaceKHR( 9194 static_cast<VkInstance>( *instance ), 9195 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ), 9196 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9197 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9198 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9199 { 9200 throwResultException( result, "vkCreateWin32SurfaceKHR" ); 9201 } 9202 } 9203 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 9204 9205 # if defined( VK_USE_PLATFORM_XCB_KHR ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9206 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9207 VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo, 9208 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9209 : m_instance( *instance ) 9210 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9211 , m_dispatcher( instance.getDispatcher() ) 9212 { 9213 VULKAN_HPP_NAMESPACE::Result result = 9214 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateXcbSurfaceKHR( 9215 static_cast<VkInstance>( *instance ), 9216 reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ), 9217 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9218 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9219 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9220 { 9221 throwResultException( result, "vkCreateXcbSurfaceKHR" ); 9222 } 9223 } 9224 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 9225 9226 # if defined( VK_USE_PLATFORM_XLIB_KHR ) SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9227 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9228 VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo, 9229 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9230 : m_instance( *instance ) 9231 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9232 , m_dispatcher( instance.getDispatcher() ) 9233 { 9234 VULKAN_HPP_NAMESPACE::Result result = 9235 static_cast<VULKAN_HPP_NAMESPACE::Result>( instance.getDispatcher()->vkCreateXlibSurfaceKHR( 9236 static_cast<VkInstance>( *instance ), 9237 reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ), 9238 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9239 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) ); 9240 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9241 { 9242 throwResultException( result, "vkCreateXlibSurfaceKHR" ); 9243 } 9244 } 9245 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 9246 SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VkSurfaceKHR surface,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9247 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 9248 VkSurfaceKHR surface, 9249 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9250 : m_instance( *instance ) 9251 , m_surface( surface ) 9252 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9253 , m_dispatcher( instance.getDispatcher() ) 9254 {} 9255 SurfaceKHR(std::nullptr_t)9256 SurfaceKHR( std::nullptr_t ) {} 9257 ~SurfaceKHR()9258 ~SurfaceKHR() 9259 { 9260 if ( m_surface ) 9261 { 9262 getDispatcher()->vkDestroySurfaceKHR( static_cast<VkInstance>( m_instance ), 9263 static_cast<VkSurfaceKHR>( m_surface ), 9264 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9265 } 9266 } 9267 9268 SurfaceKHR() = delete; 9269 SurfaceKHR( SurfaceKHR const & ) = delete; SurfaceKHR(SurfaceKHR && rhs)9270 SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT 9271 : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) ) 9272 , m_surface( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} ) ) 9273 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9274 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9275 {} 9276 SurfaceKHR & operator=( SurfaceKHR const & ) = delete; operator =(SurfaceKHR && rhs)9277 SurfaceKHR & operator =( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT 9278 { 9279 if ( this != &rhs ) 9280 { 9281 if ( m_surface ) 9282 { 9283 getDispatcher()->vkDestroySurfaceKHR( static_cast<VkInstance>( m_instance ), 9284 static_cast<VkSurfaceKHR>( m_surface ), 9285 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9286 } 9287 m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ); 9288 m_surface = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} ); 9289 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 9290 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 9291 } 9292 return *this; 9293 } 9294 operator *() const9295 VULKAN_HPP_NAMESPACE::SurfaceKHR const & operator*() const VULKAN_HPP_NOEXCEPT 9296 { 9297 return m_surface; 9298 } 9299 getInstance() const9300 VULKAN_HPP_NAMESPACE::Instance getInstance() const 9301 { 9302 return m_instance; 9303 } 9304 getDispatcher() const9305 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 9306 { 9307 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9308 return m_dispatcher; 9309 } 9310 9311 private: 9312 VULKAN_HPP_NAMESPACE::Instance m_instance = {}; 9313 VULKAN_HPP_NAMESPACE::SurfaceKHR m_surface = {}; 9314 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 9315 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 9316 }; 9317 9318 class SwapchainKHR 9319 { 9320 public: 9321 using CType = VkSwapchainKHR; 9322 9323 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 9324 VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR; 9325 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9326 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR; 9327 9328 public: SwapchainKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9329 SwapchainKHR( 9330 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9331 VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 9332 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9333 : m_device( *device ) 9334 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9335 , m_dispatcher( device.getDispatcher() ) 9336 { 9337 VULKAN_HPP_NAMESPACE::Result result = 9338 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateSwapchainKHR( 9339 static_cast<VkDevice>( *device ), 9340 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), 9341 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9342 reinterpret_cast<VkSwapchainKHR *>( &m_swapchain ) ) ); 9343 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9344 { 9345 throwResultException( result, "vkCreateSwapchainKHR" ); 9346 } 9347 } 9348 SwapchainKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkSwapchainKHR swapchain,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9349 SwapchainKHR( 9350 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9351 VkSwapchainKHR swapchain, 9352 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9353 : m_device( *device ) 9354 , m_swapchain( swapchain ) 9355 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9356 , m_dispatcher( device.getDispatcher() ) 9357 {} 9358 SwapchainKHR(std::nullptr_t)9359 SwapchainKHR( std::nullptr_t ) {} 9360 ~SwapchainKHR()9361 ~SwapchainKHR() 9362 { 9363 if ( m_swapchain ) 9364 { 9365 getDispatcher()->vkDestroySwapchainKHR( static_cast<VkDevice>( m_device ), 9366 static_cast<VkSwapchainKHR>( m_swapchain ), 9367 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9368 } 9369 } 9370 9371 SwapchainKHR() = delete; 9372 SwapchainKHR( SwapchainKHR const & ) = delete; SwapchainKHR(SwapchainKHR && rhs)9373 SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT 9374 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 9375 , m_swapchain( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} ) ) 9376 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9377 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9378 {} 9379 SwapchainKHR & operator=( SwapchainKHR const & ) = delete; operator =(SwapchainKHR && rhs)9380 SwapchainKHR & operator =( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT 9381 { 9382 if ( this != &rhs ) 9383 { 9384 if ( m_swapchain ) 9385 { 9386 getDispatcher()->vkDestroySwapchainKHR( static_cast<VkDevice>( m_device ), 9387 static_cast<VkSwapchainKHR>( m_swapchain ), 9388 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9389 } 9390 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 9391 m_swapchain = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} ); 9392 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 9393 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 9394 } 9395 return *this; 9396 } 9397 operator *() const9398 VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const VULKAN_HPP_NOEXCEPT 9399 { 9400 return m_swapchain; 9401 } 9402 getDevice() const9403 VULKAN_HPP_NAMESPACE::Device getDevice() const 9404 { 9405 return m_device; 9406 } 9407 getDispatcher() const9408 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9409 { 9410 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9411 return m_dispatcher; 9412 } 9413 9414 //=== VK_KHR_swapchain === 9415 9416 VULKAN_HPP_NODISCARD std::vector<VkImage> getImages() const; 9417 9418 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> 9419 acquireNextImage( uint64_t timeout, 9420 VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, 9421 VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 9422 9423 //=== VK_EXT_display_control === 9424 9425 VULKAN_HPP_NODISCARD uint64_t getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const; 9426 9427 //=== VK_GOOGLE_display_timing === 9428 9429 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE getRefreshCycleDurationGOOGLE() const; 9430 9431 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> 9432 getPastPresentationTimingGOOGLE() const; 9433 9434 //=== VK_KHR_shared_presentable_image === 9435 9436 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; 9437 9438 //=== VK_AMD_display_native_hdr === 9439 9440 void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT; 9441 9442 //=== VK_KHR_present_wait === 9443 9444 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresent( uint64_t presentId, uint64_t timeout ) const; 9445 9446 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 9447 //=== VK_EXT_full_screen_exclusive === 9448 9449 void acquireFullScreenExclusiveModeEXT() const; 9450 9451 void releaseFullScreenExclusiveModeEXT() const; 9452 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 9453 9454 private: 9455 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9456 VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {}; 9457 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 9458 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9459 }; 9460 9461 class SwapchainKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> 9462 { 9463 public: SwapchainKHRs(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9464 SwapchainKHRs( 9465 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9466 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, 9467 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9468 { 9469 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * dispatcher = device.getDispatcher(); 9470 std::vector<VkSwapchainKHR> swapchains( createInfos.size() ); 9471 VULKAN_HPP_NAMESPACE::Result result = 9472 static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkCreateSharedSwapchainsKHR( 9473 static_cast<VkDevice>( *device ), 9474 createInfos.size(), 9475 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), 9476 reinterpret_cast<const VkAllocationCallbacks *>( 9477 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 9478 swapchains.data() ) ); 9479 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9480 { 9481 this->reserve( createInfos.size() ); 9482 for ( auto const & swapchainKHR : swapchains ) 9483 { 9484 this->emplace_back( device, swapchainKHR, allocator ); 9485 } 9486 } 9487 else 9488 { 9489 throwResultException( result, "vkCreateSharedSwapchainsKHR" ); 9490 } 9491 } 9492 9493 SwapchainKHRs() = delete; 9494 SwapchainKHRs( SwapchainKHRs const & ) = delete; 9495 SwapchainKHRs( SwapchainKHRs && rhs ) = default; 9496 SwapchainKHRs & operator=( SwapchainKHRs const & ) = delete; 9497 SwapchainKHRs & operator=( SwapchainKHRs && rhs ) = default; 9498 }; 9499 9500 class ValidationCacheEXT 9501 { 9502 public: 9503 using CType = VkValidationCacheEXT; 9504 9505 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 9506 VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT; 9507 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9508 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT; 9509 9510 public: ValidationCacheEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9511 ValidationCacheEXT( 9512 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9513 VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo, 9514 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9515 : m_device( *device ) 9516 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9517 , m_dispatcher( device.getDispatcher() ) 9518 { 9519 VULKAN_HPP_NAMESPACE::Result result = 9520 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateValidationCacheEXT( 9521 static_cast<VkDevice>( *device ), 9522 reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ), 9523 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9524 reinterpret_cast<VkValidationCacheEXT *>( &m_validationCache ) ) ); 9525 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9526 { 9527 throwResultException( result, "vkCreateValidationCacheEXT" ); 9528 } 9529 } 9530 ValidationCacheEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkValidationCacheEXT validationCache,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9531 ValidationCacheEXT( 9532 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9533 VkValidationCacheEXT validationCache, 9534 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9535 : m_device( *device ) 9536 , m_validationCache( validationCache ) 9537 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9538 , m_dispatcher( device.getDispatcher() ) 9539 {} 9540 ValidationCacheEXT(std::nullptr_t)9541 ValidationCacheEXT( std::nullptr_t ) {} 9542 ~ValidationCacheEXT()9543 ~ValidationCacheEXT() 9544 { 9545 if ( m_validationCache ) 9546 { 9547 getDispatcher()->vkDestroyValidationCacheEXT( 9548 static_cast<VkDevice>( m_device ), 9549 static_cast<VkValidationCacheEXT>( m_validationCache ), 9550 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9551 } 9552 } 9553 9554 ValidationCacheEXT() = delete; 9555 ValidationCacheEXT( ValidationCacheEXT const & ) = delete; ValidationCacheEXT(ValidationCacheEXT && rhs)9556 ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT 9557 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 9558 , m_validationCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCache, {} ) ) 9559 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9560 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9561 {} 9562 ValidationCacheEXT & operator=( ValidationCacheEXT const & ) = delete; operator =(ValidationCacheEXT && rhs)9563 ValidationCacheEXT & operator =( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT 9564 { 9565 if ( this != &rhs ) 9566 { 9567 if ( m_validationCache ) 9568 { 9569 getDispatcher()->vkDestroyValidationCacheEXT( 9570 static_cast<VkDevice>( m_device ), 9571 static_cast<VkValidationCacheEXT>( m_validationCache ), 9572 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9573 } 9574 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 9575 m_validationCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCache, {} ); 9576 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 9577 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 9578 } 9579 return *this; 9580 } 9581 operator *() const9582 VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const VULKAN_HPP_NOEXCEPT 9583 { 9584 return m_validationCache; 9585 } 9586 getDevice() const9587 VULKAN_HPP_NAMESPACE::Device getDevice() const 9588 { 9589 return m_device; 9590 } 9591 getDispatcher() const9592 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9593 { 9594 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9595 return m_dispatcher; 9596 } 9597 9598 //=== VK_EXT_validation_cache === 9599 9600 void merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const; 9601 9602 VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const; 9603 9604 private: 9605 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9606 VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCache = {}; 9607 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 9608 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9609 }; 9610 9611 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 9612 class VideoSessionKHR 9613 { 9614 public: 9615 using CType = VkVideoSessionKHR; 9616 9617 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 9618 VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR; 9619 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9620 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 9621 9622 public: VideoSessionKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9623 VideoSessionKHR( 9624 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9625 VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, 9626 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9627 : m_device( *device ) 9628 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9629 , m_dispatcher( device.getDispatcher() ) 9630 { 9631 VULKAN_HPP_NAMESPACE::Result result = 9632 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateVideoSessionKHR( 9633 static_cast<VkDevice>( *device ), 9634 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ), 9635 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9636 reinterpret_cast<VkVideoSessionKHR *>( &m_videoSession ) ) ); 9637 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9638 { 9639 throwResultException( result, "vkCreateVideoSessionKHR" ); 9640 } 9641 } 9642 VideoSessionKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkVideoSessionKHR videoSession,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9643 VideoSessionKHR( 9644 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9645 VkVideoSessionKHR videoSession, 9646 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9647 : m_device( *device ) 9648 , m_videoSession( videoSession ) 9649 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9650 , m_dispatcher( device.getDispatcher() ) 9651 {} 9652 VideoSessionKHR(std::nullptr_t)9653 VideoSessionKHR( std::nullptr_t ) {} 9654 ~VideoSessionKHR()9655 ~VideoSessionKHR() 9656 { 9657 if ( m_videoSession ) 9658 { 9659 getDispatcher()->vkDestroyVideoSessionKHR( static_cast<VkDevice>( m_device ), 9660 static_cast<VkVideoSessionKHR>( m_videoSession ), 9661 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9662 } 9663 } 9664 9665 VideoSessionKHR() = delete; 9666 VideoSessionKHR( VideoSessionKHR const & ) = delete; VideoSessionKHR(VideoSessionKHR && rhs)9667 VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT 9668 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 9669 , m_videoSession( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSession, {} ) ) 9670 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9671 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9672 {} 9673 VideoSessionKHR & operator=( VideoSessionKHR const & ) = delete; operator =(VideoSessionKHR && rhs)9674 VideoSessionKHR & operator =( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT 9675 { 9676 if ( this != &rhs ) 9677 { 9678 if ( m_videoSession ) 9679 { 9680 getDispatcher()->vkDestroyVideoSessionKHR( static_cast<VkDevice>( m_device ), 9681 static_cast<VkVideoSessionKHR>( m_videoSession ), 9682 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9683 } 9684 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 9685 m_videoSession = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSession, {} ); 9686 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 9687 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 9688 } 9689 return *this; 9690 } 9691 operator *() const9692 VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const VULKAN_HPP_NOEXCEPT 9693 { 9694 return m_videoSession; 9695 } 9696 getDevice() const9697 VULKAN_HPP_NAMESPACE::Device getDevice() const 9698 { 9699 return m_device; 9700 } 9701 getDispatcher() const9702 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9703 { 9704 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9705 return m_dispatcher; 9706 } 9707 9708 //=== VK_KHR_video_queue === 9709 9710 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> getMemoryRequirements() const; 9711 9712 void 9713 bindMemory( ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories ) const; 9714 9715 private: 9716 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9717 VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSession = {}; 9718 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 9719 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9720 }; 9721 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 9722 9723 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 9724 class VideoSessionParametersKHR 9725 { 9726 public: 9727 using CType = VkVideoSessionParametersKHR; 9728 9729 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = 9730 VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR; 9731 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9732 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 9733 9734 public: VideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9735 VideoSessionParametersKHR( 9736 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9737 VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo, 9738 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9739 : m_device( *device ) 9740 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9741 , m_dispatcher( device.getDispatcher() ) 9742 { 9743 VULKAN_HPP_NAMESPACE::Result result = 9744 static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateVideoSessionParametersKHR( 9745 static_cast<VkDevice>( *device ), 9746 reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ), 9747 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ), 9748 reinterpret_cast<VkVideoSessionParametersKHR *>( &m_videoSessionParameters ) ) ); 9749 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9750 { 9751 throwResultException( result, "vkCreateVideoSessionParametersKHR" ); 9752 } 9753 } 9754 VideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkVideoSessionParametersKHR videoSessionParameters,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9755 VideoSessionParametersKHR( 9756 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9757 VkVideoSessionParametersKHR videoSessionParameters, 9758 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9759 : m_device( *device ) 9760 , m_videoSessionParameters( videoSessionParameters ) 9761 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9762 , m_dispatcher( device.getDispatcher() ) 9763 {} 9764 VideoSessionParametersKHR(std::nullptr_t)9765 VideoSessionParametersKHR( std::nullptr_t ) {} 9766 ~VideoSessionParametersKHR()9767 ~VideoSessionParametersKHR() 9768 { 9769 if ( m_videoSessionParameters ) 9770 { 9771 getDispatcher()->vkDestroyVideoSessionParametersKHR( 9772 static_cast<VkDevice>( m_device ), 9773 static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ), 9774 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9775 } 9776 } 9777 9778 VideoSessionParametersKHR() = delete; 9779 VideoSessionParametersKHR( VideoSessionParametersKHR const & ) = delete; VideoSessionParametersKHR(VideoSessionParametersKHR && rhs)9780 VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT 9781 : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) 9782 , m_videoSessionParameters( 9783 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} ) ) 9784 , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9785 , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9786 {} 9787 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & ) = delete; operator =(VideoSessionParametersKHR && rhs)9788 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT 9789 { 9790 if ( this != &rhs ) 9791 { 9792 if ( m_videoSessionParameters ) 9793 { 9794 getDispatcher()->vkDestroyVideoSessionParametersKHR( 9795 static_cast<VkDevice>( m_device ), 9796 static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ), 9797 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9798 } 9799 m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); 9800 m_videoSessionParameters = 9801 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} ); 9802 m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); 9803 m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); 9804 } 9805 return *this; 9806 } 9807 operator *() const9808 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const VULKAN_HPP_NOEXCEPT 9809 { 9810 return m_videoSessionParameters; 9811 } 9812 getDevice() const9813 VULKAN_HPP_NAMESPACE::Device getDevice() const 9814 { 9815 return m_device; 9816 } 9817 getDispatcher() const9818 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9819 { 9820 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9821 return m_dispatcher; 9822 } 9823 9824 //=== VK_KHR_video_queue === 9825 9826 void update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const; 9827 9828 private: 9829 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9830 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParameters = {}; 9831 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = nullptr; 9832 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9833 }; 9834 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 9835 9836 //=========================== 9837 //=== COMMAND Definitions === 9838 //=========================== 9839 9840 //=== VK_VERSION_1_0 === 9841 createInstance(VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const9842 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Instance Context::createInstance( 9843 VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo, 9844 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 9845 { 9846 return VULKAN_HPP_RAII_NAMESPACE::Instance( *this, createInfo, allocator ); 9847 } 9848 9849 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> enumeratePhysicalDevices() const9850 Instance::enumeratePhysicalDevices() const 9851 { 9852 return VULKAN_HPP_RAII_NAMESPACE::PhysicalDevices( *this ); 9853 } 9854 9855 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures() const9856 PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT 9857 { 9858 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features; 9859 getDispatcher()->vkGetPhysicalDeviceFeatures( static_cast<VkPhysicalDevice>( m_physicalDevice ), 9860 reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) ); 9861 return features; 9862 } 9863 9864 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties getFormatProperties(VULKAN_HPP_NAMESPACE::Format format) const9865 PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 9866 { 9867 VULKAN_HPP_NAMESPACE::FormatProperties formatProperties; 9868 getDispatcher()->vkGetPhysicalDeviceFormatProperties( 9869 static_cast<VkPhysicalDevice>( m_physicalDevice ), 9870 static_cast<VkFormat>( format ), 9871 reinterpret_cast<VkFormatProperties *>( &formatProperties ) ); 9872 return formatProperties; 9873 } 9874 9875 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties getImageFormatProperties(VULKAN_HPP_NAMESPACE::Format format,VULKAN_HPP_NAMESPACE::ImageType type,VULKAN_HPP_NAMESPACE::ImageTiling tiling,VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,VULKAN_HPP_NAMESPACE::ImageCreateFlags flags) const9876 PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, 9877 VULKAN_HPP_NAMESPACE::ImageType type, 9878 VULKAN_HPP_NAMESPACE::ImageTiling tiling, 9879 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 9880 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags ) const 9881 { 9882 VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties; 9883 VULKAN_HPP_NAMESPACE::Result result = 9884 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties( 9885 static_cast<VkPhysicalDevice>( m_physicalDevice ), 9886 static_cast<VkFormat>( format ), 9887 static_cast<VkImageType>( type ), 9888 static_cast<VkImageTiling>( tiling ), 9889 static_cast<VkImageUsageFlags>( usage ), 9890 static_cast<VkImageCreateFlags>( flags ), 9891 reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) ); 9892 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9893 { 9894 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); 9895 } 9896 return imageFormatProperties; 9897 } 9898 9899 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties() const9900 PhysicalDevice::getProperties() const VULKAN_HPP_NOEXCEPT 9901 { 9902 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties; 9903 getDispatcher()->vkGetPhysicalDeviceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 9904 reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) ); 9905 return properties; 9906 } 9907 9908 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> getQueueFamilyProperties() const9909 PhysicalDevice::getQueueFamilyProperties() const VULKAN_HPP_NOEXCEPT 9910 { 9911 uint32_t queueFamilyPropertyCount; 9912 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( 9913 static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 9914 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> queueFamilyProperties( queueFamilyPropertyCount ); 9915 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( 9916 static_cast<VkPhysicalDevice>( m_physicalDevice ), 9917 &queueFamilyPropertyCount, 9918 reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) ); 9919 VULKAN_HPP_ASSERT( queueFamilyPropertyCount == queueFamilyProperties.size() ); 9920 return queueFamilyProperties; 9921 } 9922 9923 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties() const9924 PhysicalDevice::getMemoryProperties() const VULKAN_HPP_NOEXCEPT 9925 { 9926 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties; 9927 getDispatcher()->vkGetPhysicalDeviceMemoryProperties( 9928 static_cast<VkPhysicalDevice>( m_physicalDevice ), 9929 reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) ); 9930 return memoryProperties; 9931 } 9932 9933 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction getProcAddr(const std::string & name) const9934 Instance::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT 9935 { 9936 return getDispatcher()->vkGetInstanceProcAddr( static_cast<VkInstance>( m_instance ), name.c_str() ); 9937 } 9938 9939 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction getProcAddr(const std::string & name) const9940 Device::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT 9941 { 9942 return getDispatcher()->vkGetDeviceProcAddr( static_cast<VkDevice>( m_device ), name.c_str() ); 9943 } 9944 createDevice(VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const9945 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Device PhysicalDevice::createDevice( 9946 VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo, 9947 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 9948 { 9949 return VULKAN_HPP_RAII_NAMESPACE::Device( *this, createInfo, allocator ); 9950 } 9951 9952 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> enumerateInstanceExtensionProperties(Optional<const std::string> layerName) const9953 Context::enumerateInstanceExtensionProperties( Optional<const std::string> layerName ) const 9954 { 9955 std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties; 9956 uint32_t propertyCount; 9957 VULKAN_HPP_NAMESPACE::Result result; 9958 do 9959 { 9960 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceExtensionProperties( 9961 layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); 9962 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 9963 { 9964 properties.resize( propertyCount ); 9965 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceExtensionProperties( 9966 layerName ? layerName->c_str() : nullptr, 9967 &propertyCount, 9968 reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); 9969 } 9970 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 9971 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9972 { 9973 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceExtensionProperties" ); 9974 } 9975 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9976 { 9977 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 9978 if ( propertyCount < properties.size() ) 9979 { 9980 properties.resize( propertyCount ); 9981 } 9982 } 9983 return properties; 9984 } 9985 9986 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> enumerateDeviceExtensionProperties(Optional<const std::string> layerName) const9987 PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName ) const 9988 { 9989 std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties; 9990 uint32_t propertyCount; 9991 VULKAN_HPP_NAMESPACE::Result result; 9992 do 9993 { 9994 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 9995 getDispatcher()->vkEnumerateDeviceExtensionProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 9996 layerName ? layerName->c_str() : nullptr, 9997 &propertyCount, 9998 nullptr ) ); 9999 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 10000 { 10001 properties.resize( propertyCount ); 10002 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateDeviceExtensionProperties( 10003 static_cast<VkPhysicalDevice>( m_physicalDevice ), 10004 layerName ? layerName->c_str() : nullptr, 10005 &propertyCount, 10006 reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); 10007 } 10008 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 10009 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10010 { 10011 throwResultException( result, 10012 VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); 10013 } 10014 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10015 { 10016 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 10017 if ( propertyCount < properties.size() ) 10018 { 10019 properties.resize( propertyCount ); 10020 } 10021 } 10022 return properties; 10023 } 10024 10025 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateInstanceLayerProperties() const10026 Context::enumerateInstanceLayerProperties() const 10027 { 10028 std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties; 10029 uint32_t propertyCount; 10030 VULKAN_HPP_NAMESPACE::Result result; 10031 do 10032 { 10033 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10034 getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); 10035 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 10036 { 10037 properties.resize( propertyCount ); 10038 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceLayerProperties( 10039 &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); 10040 } 10041 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 10042 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10043 { 10044 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceLayerProperties" ); 10045 } 10046 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10047 { 10048 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 10049 if ( propertyCount < properties.size() ) 10050 { 10051 properties.resize( propertyCount ); 10052 } 10053 } 10054 return properties; 10055 } 10056 10057 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateDeviceLayerProperties() const10058 PhysicalDevice::enumerateDeviceLayerProperties() const 10059 { 10060 std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties; 10061 uint32_t propertyCount; 10062 VULKAN_HPP_NAMESPACE::Result result; 10063 do 10064 { 10065 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateDeviceLayerProperties( 10066 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 10067 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 10068 { 10069 properties.resize( propertyCount ); 10070 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateDeviceLayerProperties( 10071 static_cast<VkPhysicalDevice>( m_physicalDevice ), 10072 &propertyCount, 10073 reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); 10074 } 10075 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 10076 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10077 { 10078 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); 10079 } 10080 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10081 { 10082 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 10083 if ( propertyCount < properties.size() ) 10084 { 10085 properties.resize( propertyCount ); 10086 } 10087 } 10088 return properties; 10089 } 10090 10091 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Queue getQueue(uint32_t queueFamilyIndex,uint32_t queueIndex) const10092 Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const 10093 { 10094 return VULKAN_HPP_RAII_NAMESPACE::Queue( *this, queueFamilyIndex, queueIndex ); 10095 } 10096 submit(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,VULKAN_HPP_NAMESPACE::Fence fence) const10097 VULKAN_HPP_INLINE void Queue::submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits, 10098 VULKAN_HPP_NAMESPACE::Fence fence ) const 10099 { 10100 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10101 getDispatcher()->vkQueueSubmit( static_cast<VkQueue>( m_queue ), 10102 submits.size(), 10103 reinterpret_cast<const VkSubmitInfo *>( submits.data() ), 10104 static_cast<VkFence>( fence ) ) ); 10105 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10106 { 10107 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" ); 10108 } 10109 } 10110 waitIdle() const10111 VULKAN_HPP_INLINE void Queue::waitIdle() const 10112 { 10113 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10114 getDispatcher()->vkQueueWaitIdle( static_cast<VkQueue>( m_queue ) ) ); 10115 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10116 { 10117 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" ); 10118 } 10119 } 10120 waitIdle() const10121 VULKAN_HPP_INLINE void Device::waitIdle() const 10122 { 10123 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10124 getDispatcher()->vkDeviceWaitIdle( static_cast<VkDevice>( m_device ) ) ); 10125 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10126 { 10127 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" ); 10128 } 10129 } 10130 allocateMemory(VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10131 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DeviceMemory Device::allocateMemory( 10132 VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo, 10133 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10134 { 10135 return VULKAN_HPP_RAII_NAMESPACE::DeviceMemory( *this, allocateInfo, allocator ); 10136 } 10137 10138 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * mapMemory(VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::DeviceSize size,VULKAN_HPP_NAMESPACE::MemoryMapFlags flags) const10139 DeviceMemory::mapMemory( VULKAN_HPP_NAMESPACE::DeviceSize offset, 10140 VULKAN_HPP_NAMESPACE::DeviceSize size, 10141 VULKAN_HPP_NAMESPACE::MemoryMapFlags flags ) const 10142 { 10143 void * pData; 10144 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10145 getDispatcher()->vkMapMemory( static_cast<VkDevice>( m_device ), 10146 static_cast<VkDeviceMemory>( m_memory ), 10147 static_cast<VkDeviceSize>( offset ), 10148 static_cast<VkDeviceSize>( size ), 10149 static_cast<VkMemoryMapFlags>( flags ), 10150 &pData ) ); 10151 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10152 { 10153 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory" ); 10154 } 10155 return pData; 10156 } 10157 unmapMemory() const10158 VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT 10159 { 10160 getDispatcher()->vkUnmapMemory( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ) ); 10161 } 10162 flushMappedMemoryRanges(ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges) const10163 VULKAN_HPP_INLINE void Device::flushMappedMemoryRanges( 10164 ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const 10165 { 10166 VULKAN_HPP_NAMESPACE::Result result = 10167 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkFlushMappedMemoryRanges( 10168 static_cast<VkDevice>( m_device ), 10169 memoryRanges.size(), 10170 reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) ); 10171 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10172 { 10173 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); 10174 } 10175 } 10176 invalidateMappedMemoryRanges(ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges) const10177 VULKAN_HPP_INLINE void Device::invalidateMappedMemoryRanges( 10178 ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const 10179 { 10180 VULKAN_HPP_NAMESPACE::Result result = 10181 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInvalidateMappedMemoryRanges( 10182 static_cast<VkDevice>( m_device ), 10183 memoryRanges.size(), 10184 reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) ); 10185 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10186 { 10187 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); 10188 } 10189 } 10190 10191 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize getCommitment() const10192 DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT 10193 { 10194 VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes; 10195 getDispatcher()->vkGetDeviceMemoryCommitment( static_cast<VkDevice>( m_device ), 10196 static_cast<VkDeviceMemory>( m_memory ), 10197 reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) ); 10198 return committedMemoryInBytes; 10199 } 10200 bindMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory,VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset) const10201 VULKAN_HPP_INLINE void Buffer::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, 10202 VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const 10203 { 10204 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10205 getDispatcher()->vkBindBufferMemory( static_cast<VkDevice>( m_device ), 10206 static_cast<VkBuffer>( m_buffer ), 10207 static_cast<VkDeviceMemory>( memory ), 10208 static_cast<VkDeviceSize>( memoryOffset ) ) ); 10209 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10210 { 10211 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Buffer::bindMemory" ); 10212 } 10213 } 10214 bindMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory,VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset) const10215 VULKAN_HPP_INLINE void Image::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, 10216 VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const 10217 { 10218 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10219 getDispatcher()->vkBindImageMemory( static_cast<VkDevice>( m_device ), 10220 static_cast<VkImage>( m_image ), 10221 static_cast<VkDeviceMemory>( memory ), 10222 static_cast<VkDeviceSize>( memoryOffset ) ) ); 10223 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10224 { 10225 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Image::bindMemory" ); 10226 } 10227 } 10228 10229 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const10230 Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT 10231 { 10232 VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; 10233 getDispatcher()->vkGetBufferMemoryRequirements( static_cast<VkDevice>( m_device ), 10234 static_cast<VkBuffer>( m_buffer ), 10235 reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) ); 10236 return memoryRequirements; 10237 } 10238 10239 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const10240 Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT 10241 { 10242 VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; 10243 getDispatcher()->vkGetImageMemoryRequirements( static_cast<VkDevice>( m_device ), 10244 static_cast<VkImage>( m_image ), 10245 reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) ); 10246 return memoryRequirements; 10247 } 10248 10249 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> getSparseMemoryRequirements() const10250 Image::getSparseMemoryRequirements() const VULKAN_HPP_NOEXCEPT 10251 { 10252 uint32_t sparseMemoryRequirementCount; 10253 getDispatcher()->vkGetImageSparseMemoryRequirements( 10254 static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr ); 10255 std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements( 10256 sparseMemoryRequirementCount ); 10257 getDispatcher()->vkGetImageSparseMemoryRequirements( 10258 static_cast<VkDevice>( m_device ), 10259 static_cast<VkImage>( m_image ), 10260 &sparseMemoryRequirementCount, 10261 reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) ); 10262 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount == sparseMemoryRequirements.size() ); 10263 return sparseMemoryRequirements; 10264 } 10265 10266 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> getSparseImageFormatProperties(VULKAN_HPP_NAMESPACE::Format format,VULKAN_HPP_NAMESPACE::ImageType type,VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,VULKAN_HPP_NAMESPACE::ImageTiling tiling) const10267 PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, 10268 VULKAN_HPP_NAMESPACE::ImageType type, 10269 VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, 10270 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 10271 VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const 10272 VULKAN_HPP_NOEXCEPT 10273 { 10274 uint32_t propertyCount; 10275 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( 10276 static_cast<VkPhysicalDevice>( m_physicalDevice ), 10277 static_cast<VkFormat>( format ), 10278 static_cast<VkImageType>( type ), 10279 static_cast<VkSampleCountFlagBits>( samples ), 10280 static_cast<VkImageUsageFlags>( usage ), 10281 static_cast<VkImageTiling>( tiling ), 10282 &propertyCount, 10283 nullptr ); 10284 std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> properties( propertyCount ); 10285 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( 10286 static_cast<VkPhysicalDevice>( m_physicalDevice ), 10287 static_cast<VkFormat>( format ), 10288 static_cast<VkImageType>( type ), 10289 static_cast<VkSampleCountFlagBits>( samples ), 10290 static_cast<VkImageUsageFlags>( usage ), 10291 static_cast<VkImageTiling>( tiling ), 10292 &propertyCount, 10293 reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) ); 10294 VULKAN_HPP_ASSERT( propertyCount == properties.size() ); 10295 return properties; 10296 } 10297 bindSparse(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,VULKAN_HPP_NAMESPACE::Fence fence) const10298 VULKAN_HPP_INLINE void Queue::bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo, 10299 VULKAN_HPP_NAMESPACE::Fence fence ) const 10300 { 10301 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10302 getDispatcher()->vkQueueBindSparse( static_cast<VkQueue>( m_queue ), 10303 bindInfo.size(), 10304 reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ), 10305 static_cast<VkFence>( fence ) ) ); 10306 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10307 { 10308 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" ); 10309 } 10310 } 10311 createFence(VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10312 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Fence Device::createFence( 10313 VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo, 10314 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10315 { 10316 return VULKAN_HPP_RAII_NAMESPACE::Fence( *this, createInfo, allocator ); 10317 } 10318 resetFences(ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences) const10319 VULKAN_HPP_INLINE void Device::resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const 10320 { 10321 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetFences( 10322 static_cast<VkDevice>( m_device ), fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) ); 10323 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10324 { 10325 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" ); 10326 } 10327 } 10328 getStatus() const10329 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Fence::getStatus() const 10330 { 10331 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10332 getDispatcher()->vkGetFenceStatus( static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ) ) ); 10333 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 10334 ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) ) 10335 { 10336 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Fence::getStatus" ); 10337 } 10338 return result; 10339 } 10340 10341 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result waitForFences(ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,VULKAN_HPP_NAMESPACE::Bool32 waitAll,uint64_t timeout) const10342 Device::waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, 10343 VULKAN_HPP_NAMESPACE::Bool32 waitAll, 10344 uint64_t timeout ) const 10345 { 10346 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10347 getDispatcher()->vkWaitForFences( static_cast<VkDevice>( m_device ), 10348 fences.size(), 10349 reinterpret_cast<const VkFence *>( fences.data() ), 10350 static_cast<VkBool32>( waitAll ), 10351 timeout ) ); 10352 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 10353 ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) ) 10354 { 10355 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences" ); 10356 } 10357 return result; 10358 } 10359 createSemaphore(VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10360 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Semaphore Device::createSemaphore( 10361 VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo, 10362 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10363 { 10364 return VULKAN_HPP_RAII_NAMESPACE::Semaphore( *this, createInfo, allocator ); 10365 } 10366 createEvent(VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10367 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Event Device::createEvent( 10368 VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo, 10369 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10370 { 10371 return VULKAN_HPP_RAII_NAMESPACE::Event( *this, createInfo, allocator ); 10372 } 10373 getStatus() const10374 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Event::getStatus() const 10375 { 10376 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10377 getDispatcher()->vkGetEventStatus( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) ); 10378 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eEventSet ) && 10379 ( result != VULKAN_HPP_NAMESPACE::Result::eEventReset ) ) 10380 { 10381 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::getStatus" ); 10382 } 10383 return result; 10384 } 10385 set() const10386 VULKAN_HPP_INLINE void Event::set() const 10387 { 10388 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10389 getDispatcher()->vkSetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) ); 10390 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10391 { 10392 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::set" ); 10393 } 10394 } 10395 reset() const10396 VULKAN_HPP_INLINE void Event::reset() const 10397 { 10398 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10399 getDispatcher()->vkResetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) ); 10400 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10401 { 10402 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Event::reset" ); 10403 } 10404 } 10405 createQueryPool(VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10406 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::QueryPool Device::createQueryPool( 10407 VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo, 10408 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10409 { 10410 return VULKAN_HPP_RAII_NAMESPACE::QueryPool( *this, createInfo, allocator ); 10411 } 10412 10413 template <typename T> 10414 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<T>> getResults(uint32_t firstQuery,uint32_t queryCount,size_t dataSize,VULKAN_HPP_NAMESPACE::DeviceSize stride,VULKAN_HPP_NAMESPACE::QueryResultFlags flags) const10415 QueryPool::getResults( uint32_t firstQuery, 10416 uint32_t queryCount, 10417 size_t dataSize, 10418 VULKAN_HPP_NAMESPACE::DeviceSize stride, 10419 VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const 10420 { 10421 VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); 10422 std::vector<T> data( dataSize / sizeof( T ) ); 10423 Result result = 10424 static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ), 10425 static_cast<VkQueryPool>( m_queryPool ), 10426 firstQuery, 10427 queryCount, 10428 data.size() * sizeof( T ), 10429 reinterpret_cast<void *>( data.data() ), 10430 static_cast<VkDeviceSize>( stride ), 10431 static_cast<VkQueryResultFlags>( flags ) ) ); 10432 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 10433 ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) ) 10434 { 10435 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResults" ); 10436 } 10437 return std::make_pair( result, data ); 10438 } 10439 10440 template <typename T> 10441 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, T> getResult(uint32_t firstQuery,uint32_t queryCount,VULKAN_HPP_NAMESPACE::DeviceSize stride,VULKAN_HPP_NAMESPACE::QueryResultFlags flags) const10442 QueryPool::getResult( uint32_t firstQuery, 10443 uint32_t queryCount, 10444 VULKAN_HPP_NAMESPACE::DeviceSize stride, 10445 VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const 10446 { 10447 T data; 10448 Result result = 10449 static_cast<Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ), 10450 static_cast<VkQueryPool>( m_queryPool ), 10451 firstQuery, 10452 queryCount, 10453 sizeof( T ), 10454 reinterpret_cast<void *>( &data ), 10455 static_cast<VkDeviceSize>( stride ), 10456 static_cast<VkQueryResultFlags>( flags ) ) ); 10457 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 10458 ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) ) 10459 { 10460 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResult" ); 10461 } 10462 return std::make_pair( result, data ); 10463 } 10464 createBuffer(VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10465 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Buffer Device::createBuffer( 10466 VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo, 10467 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10468 { 10469 return VULKAN_HPP_RAII_NAMESPACE::Buffer( *this, createInfo, allocator ); 10470 } 10471 createBufferView(VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10472 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::BufferView Device::createBufferView( 10473 VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo, 10474 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10475 { 10476 return VULKAN_HPP_RAII_NAMESPACE::BufferView( *this, createInfo, allocator ); 10477 } 10478 createImage(VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10479 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Image Device::createImage( 10480 VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo, 10481 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10482 { 10483 return VULKAN_HPP_RAII_NAMESPACE::Image( *this, createInfo, allocator ); 10484 } 10485 getSubresourceLayout(const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource) const10486 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout Image::getSubresourceLayout( 10487 const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT 10488 { 10489 VULKAN_HPP_NAMESPACE::SubresourceLayout layout; 10490 getDispatcher()->vkGetImageSubresourceLayout( static_cast<VkDevice>( m_device ), 10491 static_cast<VkImage>( m_image ), 10492 reinterpret_cast<const VkImageSubresource *>( &subresource ), 10493 reinterpret_cast<VkSubresourceLayout *>( &layout ) ); 10494 return layout; 10495 } 10496 createImageView(VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10497 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ImageView Device::createImageView( 10498 VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo, 10499 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10500 { 10501 return VULKAN_HPP_RAII_NAMESPACE::ImageView( *this, createInfo, allocator ); 10502 } 10503 createShaderModule(VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10504 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ShaderModule Device::createShaderModule( 10505 VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo, 10506 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10507 { 10508 return VULKAN_HPP_RAII_NAMESPACE::ShaderModule( *this, createInfo, allocator ); 10509 } 10510 createPipelineCache(VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10511 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PipelineCache Device::createPipelineCache( 10512 VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo, 10513 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10514 { 10515 return VULKAN_HPP_RAII_NAMESPACE::PipelineCache( *this, createInfo, allocator ); 10516 } 10517 getData() const10518 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> PipelineCache::getData() const 10519 { 10520 std::vector<uint8_t> data; 10521 size_t dataSize; 10522 VULKAN_HPP_NAMESPACE::Result result; 10523 do 10524 { 10525 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineCacheData( 10526 static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, nullptr ) ); 10527 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) 10528 { 10529 data.resize( dataSize ); 10530 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10531 getDispatcher()->vkGetPipelineCacheData( static_cast<VkDevice>( m_device ), 10532 static_cast<VkPipelineCache>( m_pipelineCache ), 10533 &dataSize, 10534 reinterpret_cast<void *>( data.data() ) ) ); 10535 } 10536 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 10537 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10538 { 10539 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::getData" ); 10540 } 10541 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10542 { 10543 VULKAN_HPP_ASSERT( dataSize <= data.size() ); 10544 if ( dataSize < data.size() ) 10545 { 10546 data.resize( dataSize ); 10547 } 10548 } 10549 return data; 10550 } 10551 10552 VULKAN_HPP_INLINE void merge(ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches) const10553 PipelineCache::merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const 10554 { 10555 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10556 getDispatcher()->vkMergePipelineCaches( static_cast<VkDevice>( m_device ), 10557 static_cast<VkPipelineCache>( m_pipelineCache ), 10558 srcCaches.size(), 10559 reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) ); 10560 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10561 { 10562 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::merge" ); 10563 } 10564 } 10565 10566 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createGraphicsPipelines(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10567 Device::createGraphicsPipelines( 10568 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 10569 pipelineCache, 10570 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, 10571 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10572 { 10573 return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, pipelineCache, createInfos, allocator ); 10574 } 10575 createGraphicsPipeline(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10576 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createGraphicsPipeline( 10577 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 10578 pipelineCache, 10579 VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo, 10580 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10581 { 10582 return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator ); 10583 } 10584 10585 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createComputePipelines(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10586 Device::createComputePipelines( 10587 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 10588 pipelineCache, 10589 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, 10590 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10591 { 10592 return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, pipelineCache, createInfos, allocator ); 10593 } 10594 createComputePipeline(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10595 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createComputePipeline( 10596 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 10597 pipelineCache, 10598 VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo, 10599 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10600 { 10601 return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator ); 10602 } 10603 createPipelineLayout(VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10604 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PipelineLayout Device::createPipelineLayout( 10605 VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo, 10606 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10607 { 10608 return VULKAN_HPP_RAII_NAMESPACE::PipelineLayout( *this, createInfo, allocator ); 10609 } 10610 createSampler(VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10611 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Sampler Device::createSampler( 10612 VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo, 10613 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10614 { 10615 return VULKAN_HPP_RAII_NAMESPACE::Sampler( *this, createInfo, allocator ); 10616 } 10617 10618 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout createDescriptorSetLayout(VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10619 Device::createDescriptorSetLayout( 10620 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo, 10621 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10622 { 10623 return VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout( *this, createInfo, allocator ); 10624 } 10625 createDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10626 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorPool Device::createDescriptorPool( 10627 VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo, 10628 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10629 { 10630 return VULKAN_HPP_RAII_NAMESPACE::DescriptorPool( *this, createInfo, allocator ); 10631 } 10632 10633 VULKAN_HPP_INLINE void reset(VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags) const10634 DescriptorPool::reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT 10635 { 10636 getDispatcher()->vkResetDescriptorPool( static_cast<VkDevice>( m_device ), 10637 static_cast<VkDescriptorPool>( m_descriptorPool ), 10638 static_cast<VkDescriptorPoolResetFlags>( flags ) ); 10639 } 10640 10641 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> allocateDescriptorSets(VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo) const10642 Device::allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const 10643 { 10644 return VULKAN_HPP_RAII_NAMESPACE::DescriptorSets( *this, allocateInfo ); 10645 } 10646 updateDescriptorSets(ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies) const10647 VULKAN_HPP_INLINE void Device::updateDescriptorSets( 10648 ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, 10649 ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT 10650 { 10651 getDispatcher()->vkUpdateDescriptorSets( 10652 static_cast<VkDevice>( m_device ), 10653 descriptorWrites.size(), 10654 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ), 10655 descriptorCopies.size(), 10656 reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) ); 10657 } 10658 createFramebuffer(VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10659 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Framebuffer Device::createFramebuffer( 10660 VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo, 10661 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10662 { 10663 return VULKAN_HPP_RAII_NAMESPACE::Framebuffer( *this, createInfo, allocator ); 10664 } 10665 createRenderPass(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10666 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::RenderPass Device::createRenderPass( 10667 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo, 10668 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10669 { 10670 return VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, createInfo, allocator ); 10671 } 10672 10673 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity() const10674 RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT 10675 { 10676 VULKAN_HPP_NAMESPACE::Extent2D granularity; 10677 getDispatcher()->vkGetRenderAreaGranularity( static_cast<VkDevice>( m_device ), 10678 static_cast<VkRenderPass>( m_renderPass ), 10679 reinterpret_cast<VkExtent2D *>( &granularity ) ); 10680 return granularity; 10681 } 10682 createCommandPool(VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const10683 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::CommandPool Device::createCommandPool( 10684 VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo, 10685 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 10686 { 10687 return VULKAN_HPP_RAII_NAMESPACE::CommandPool( *this, createInfo, allocator ); 10688 } 10689 reset(VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags) const10690 VULKAN_HPP_INLINE void CommandPool::reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags ) const 10691 { 10692 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10693 getDispatcher()->vkResetCommandPool( static_cast<VkDevice>( m_device ), 10694 static_cast<VkCommandPool>( m_commandPool ), 10695 static_cast<VkCommandPoolResetFlags>( flags ) ) ); 10696 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10697 { 10698 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandPool::reset" ); 10699 } 10700 } 10701 10702 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> allocateCommandBuffers(VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo) const10703 Device::allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const 10704 { 10705 return VULKAN_HPP_RAII_NAMESPACE::CommandBuffers( *this, allocateInfo ); 10706 } 10707 begin(const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo) const10708 VULKAN_HPP_INLINE void CommandBuffer::begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const 10709 { 10710 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10711 getDispatcher()->vkBeginCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 10712 reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) ); 10713 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10714 { 10715 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" ); 10716 } 10717 } 10718 end() const10719 VULKAN_HPP_INLINE void CommandBuffer::end() const 10720 { 10721 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 10722 getDispatcher()->vkEndCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ) ) ); 10723 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10724 { 10725 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" ); 10726 } 10727 } 10728 reset(VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags) const10729 VULKAN_HPP_INLINE void CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags ) const 10730 { 10731 VULKAN_HPP_NAMESPACE::Result result = 10732 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetCommandBuffer( 10733 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCommandBufferResetFlags>( flags ) ) ); 10734 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 10735 { 10736 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" ); 10737 } 10738 } 10739 10740 VULKAN_HPP_INLINE void bindPipeline(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::Pipeline pipeline) const10741 CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 10742 VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT 10743 { 10744 getDispatcher()->vkCmdBindPipeline( static_cast<VkCommandBuffer>( m_commandBuffer ), 10745 static_cast<VkPipelineBindPoint>( pipelineBindPoint ), 10746 static_cast<VkPipeline>( pipeline ) ); 10747 } 10748 setViewport(uint32_t firstViewport,ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports) const10749 VULKAN_HPP_INLINE void CommandBuffer::setViewport( 10750 uint32_t firstViewport, 10751 ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT 10752 { 10753 getDispatcher()->vkCmdSetViewport( static_cast<VkCommandBuffer>( m_commandBuffer ), 10754 firstViewport, 10755 viewports.size(), 10756 reinterpret_cast<const VkViewport *>( viewports.data() ) ); 10757 } 10758 setScissor(uint32_t firstScissor,ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors) const10759 VULKAN_HPP_INLINE void CommandBuffer::setScissor( 10760 uint32_t firstScissor, ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT 10761 { 10762 getDispatcher()->vkCmdSetScissor( static_cast<VkCommandBuffer>( m_commandBuffer ), 10763 firstScissor, 10764 scissors.size(), 10765 reinterpret_cast<const VkRect2D *>( scissors.data() ) ); 10766 } 10767 setLineWidth(float lineWidth) const10768 VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT 10769 { 10770 getDispatcher()->vkCmdSetLineWidth( static_cast<VkCommandBuffer>( m_commandBuffer ), lineWidth ); 10771 } 10772 setDepthBias(float depthBiasConstantFactor,float depthBiasClamp,float depthBiasSlopeFactor) const10773 VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, 10774 float depthBiasClamp, 10775 float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT 10776 { 10777 getDispatcher()->vkCmdSetDepthBias( static_cast<VkCommandBuffer>( m_commandBuffer ), 10778 depthBiasConstantFactor, 10779 depthBiasClamp, 10780 depthBiasSlopeFactor ); 10781 } 10782 setBlendConstants(const float blendConstants[4]) const10783 VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT 10784 { 10785 getDispatcher()->vkCmdSetBlendConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), blendConstants ); 10786 } 10787 setDepthBounds(float minDepthBounds,float maxDepthBounds) const10788 VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, 10789 float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT 10790 { 10791 getDispatcher()->vkCmdSetDepthBounds( 10792 static_cast<VkCommandBuffer>( m_commandBuffer ), minDepthBounds, maxDepthBounds ); 10793 } 10794 setStencilCompareMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,uint32_t compareMask) const10795 VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 10796 uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT 10797 { 10798 getDispatcher()->vkCmdSetStencilCompareMask( 10799 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), compareMask ); 10800 } 10801 setStencilWriteMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,uint32_t writeMask) const10802 VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 10803 uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT 10804 { 10805 getDispatcher()->vkCmdSetStencilWriteMask( 10806 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), writeMask ); 10807 } 10808 setStencilReference(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,uint32_t reference) const10809 VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 10810 uint32_t reference ) const VULKAN_HPP_NOEXCEPT 10811 { 10812 getDispatcher()->vkCmdSetStencilReference( 10813 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), reference ); 10814 } 10815 10816 VULKAN_HPP_INLINE void bindDescriptorSets(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t firstSet,ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,ArrayProxy<const uint32_t> const & dynamicOffsets) const10817 CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 10818 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 10819 uint32_t firstSet, 10820 ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, 10821 ArrayProxy<const uint32_t> const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT 10822 { 10823 getDispatcher()->vkCmdBindDescriptorSets( static_cast<VkCommandBuffer>( m_commandBuffer ), 10824 static_cast<VkPipelineBindPoint>( pipelineBindPoint ), 10825 static_cast<VkPipelineLayout>( layout ), 10826 firstSet, 10827 descriptorSets.size(), 10828 reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ), 10829 dynamicOffsets.size(), 10830 dynamicOffsets.data() ); 10831 } 10832 10833 VULKAN_HPP_INLINE void bindIndexBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::IndexType indexType) const10834 CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, 10835 VULKAN_HPP_NAMESPACE::DeviceSize offset, 10836 VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT 10837 { 10838 getDispatcher()->vkCmdBindIndexBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 10839 static_cast<VkBuffer>( buffer ), 10840 static_cast<VkDeviceSize>( offset ), 10841 static_cast<VkIndexType>( indexType ) ); 10842 } 10843 bindVertexBuffers(uint32_t firstBinding,ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets) const10844 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( 10845 uint32_t firstBinding, 10846 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 10847 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 10848 { 10849 # ifdef VULKAN_HPP_NO_EXCEPTIONS 10850 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); 10851 # else 10852 if ( buffers.size() != offsets.size() ) 10853 { 10854 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 10855 "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); 10856 } 10857 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 10858 10859 getDispatcher()->vkCmdBindVertexBuffers( static_cast<VkCommandBuffer>( m_commandBuffer ), 10860 firstBinding, 10861 buffers.size(), 10862 reinterpret_cast<const VkBuffer *>( buffers.data() ), 10863 reinterpret_cast<const VkDeviceSize *>( offsets.data() ) ); 10864 } 10865 draw(uint32_t vertexCount,uint32_t instanceCount,uint32_t firstVertex,uint32_t firstInstance) const10866 VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, 10867 uint32_t instanceCount, 10868 uint32_t firstVertex, 10869 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT 10870 { 10871 getDispatcher()->vkCmdDraw( 10872 static_cast<VkCommandBuffer>( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance ); 10873 } 10874 drawIndexed(uint32_t indexCount,uint32_t instanceCount,uint32_t firstIndex,int32_t vertexOffset,uint32_t firstInstance) const10875 VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, 10876 uint32_t instanceCount, 10877 uint32_t firstIndex, 10878 int32_t vertexOffset, 10879 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT 10880 { 10881 getDispatcher()->vkCmdDrawIndexed( static_cast<VkCommandBuffer>( m_commandBuffer ), 10882 indexCount, 10883 instanceCount, 10884 firstIndex, 10885 vertexOffset, 10886 firstInstance ); 10887 } 10888 drawIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,uint32_t drawCount,uint32_t stride) const10889 VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 10890 VULKAN_HPP_NAMESPACE::DeviceSize offset, 10891 uint32_t drawCount, 10892 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 10893 { 10894 getDispatcher()->vkCmdDrawIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ), 10895 static_cast<VkBuffer>( buffer ), 10896 static_cast<VkDeviceSize>( offset ), 10897 drawCount, 10898 stride ); 10899 } 10900 drawIndexedIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,uint32_t drawCount,uint32_t stride) const10901 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 10902 VULKAN_HPP_NAMESPACE::DeviceSize offset, 10903 uint32_t drawCount, 10904 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 10905 { 10906 getDispatcher()->vkCmdDrawIndexedIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ), 10907 static_cast<VkBuffer>( buffer ), 10908 static_cast<VkDeviceSize>( offset ), 10909 drawCount, 10910 stride ); 10911 } 10912 dispatch(uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const10913 VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, 10914 uint32_t groupCountY, 10915 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 10916 { 10917 getDispatcher()->vkCmdDispatch( 10918 static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); 10919 } 10920 10921 VULKAN_HPP_INLINE void dispatchIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset) const10922 CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 10923 VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT 10924 { 10925 getDispatcher()->vkCmdDispatchIndirect( static_cast<VkCommandBuffer>( m_commandBuffer ), 10926 static_cast<VkBuffer>( buffer ), 10927 static_cast<VkDeviceSize>( offset ) ); 10928 } 10929 copyBuffer(VULKAN_HPP_NAMESPACE::Buffer srcBuffer,VULKAN_HPP_NAMESPACE::Buffer dstBuffer,ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions) const10930 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( 10931 VULKAN_HPP_NAMESPACE::Buffer srcBuffer, 10932 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 10933 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT 10934 { 10935 getDispatcher()->vkCmdCopyBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 10936 static_cast<VkBuffer>( srcBuffer ), 10937 static_cast<VkBuffer>( dstBuffer ), 10938 regions.size(), 10939 reinterpret_cast<const VkBufferCopy *>( regions.data() ) ); 10940 } 10941 copyImage(VULKAN_HPP_NAMESPACE::Image srcImage,VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,VULKAN_HPP_NAMESPACE::Image dstImage,VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions) const10942 VULKAN_HPP_INLINE void CommandBuffer::copyImage( 10943 VULKAN_HPP_NAMESPACE::Image srcImage, 10944 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 10945 VULKAN_HPP_NAMESPACE::Image dstImage, 10946 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 10947 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT 10948 { 10949 getDispatcher()->vkCmdCopyImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 10950 static_cast<VkImage>( srcImage ), 10951 static_cast<VkImageLayout>( srcImageLayout ), 10952 static_cast<VkImage>( dstImage ), 10953 static_cast<VkImageLayout>( dstImageLayout ), 10954 regions.size(), 10955 reinterpret_cast<const VkImageCopy *>( regions.data() ) ); 10956 } 10957 blitImage(VULKAN_HPP_NAMESPACE::Image srcImage,VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,VULKAN_HPP_NAMESPACE::Image dstImage,VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,VULKAN_HPP_NAMESPACE::Filter filter) const10958 VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, 10959 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 10960 VULKAN_HPP_NAMESPACE::Image dstImage, 10961 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 10962 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions, 10963 VULKAN_HPP_NAMESPACE::Filter filter ) const VULKAN_HPP_NOEXCEPT 10964 { 10965 getDispatcher()->vkCmdBlitImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 10966 static_cast<VkImage>( srcImage ), 10967 static_cast<VkImageLayout>( srcImageLayout ), 10968 static_cast<VkImage>( dstImage ), 10969 static_cast<VkImageLayout>( dstImageLayout ), 10970 regions.size(), 10971 reinterpret_cast<const VkImageBlit *>( regions.data() ), 10972 static_cast<VkFilter>( filter ) ); 10973 } 10974 copyBufferToImage(VULKAN_HPP_NAMESPACE::Buffer srcBuffer,VULKAN_HPP_NAMESPACE::Image dstImage,VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions) const10975 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( 10976 VULKAN_HPP_NAMESPACE::Buffer srcBuffer, 10977 VULKAN_HPP_NAMESPACE::Image dstImage, 10978 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 10979 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT 10980 { 10981 getDispatcher()->vkCmdCopyBufferToImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 10982 static_cast<VkBuffer>( srcBuffer ), 10983 static_cast<VkImage>( dstImage ), 10984 static_cast<VkImageLayout>( dstImageLayout ), 10985 regions.size(), 10986 reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) ); 10987 } 10988 copyImageToBuffer(VULKAN_HPP_NAMESPACE::Image srcImage,VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,VULKAN_HPP_NAMESPACE::Buffer dstBuffer,ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions) const10989 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( 10990 VULKAN_HPP_NAMESPACE::Image srcImage, 10991 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 10992 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 10993 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT 10994 { 10995 getDispatcher()->vkCmdCopyImageToBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 10996 static_cast<VkImage>( srcImage ), 10997 static_cast<VkImageLayout>( srcImageLayout ), 10998 static_cast<VkBuffer>( dstBuffer ), 10999 regions.size(), 11000 reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) ); 11001 } 11002 11003 template <typename T> updateBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,ArrayProxy<const T> const & data) const11004 VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 11005 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 11006 ArrayProxy<const T> const & data ) const VULKAN_HPP_NOEXCEPT 11007 { 11008 getDispatcher()->vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 11009 static_cast<VkBuffer>( dstBuffer ), 11010 static_cast<VkDeviceSize>( dstOffset ), 11011 data.size() * sizeof( T ), 11012 reinterpret_cast<const void *>( data.data() ) ); 11013 } 11014 fillBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,VULKAN_HPP_NAMESPACE::DeviceSize size,uint32_t data) const11015 VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 11016 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 11017 VULKAN_HPP_NAMESPACE::DeviceSize size, 11018 uint32_t data ) const VULKAN_HPP_NOEXCEPT 11019 { 11020 getDispatcher()->vkCmdFillBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 11021 static_cast<VkBuffer>( dstBuffer ), 11022 static_cast<VkDeviceSize>( dstOffset ), 11023 static_cast<VkDeviceSize>( size ), 11024 data ); 11025 } 11026 clearColorImage(VULKAN_HPP_NAMESPACE::Image image,VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,const VULKAN_HPP_NAMESPACE::ClearColorValue & color,ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges) const11027 VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( 11028 VULKAN_HPP_NAMESPACE::Image image, 11029 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, 11030 const VULKAN_HPP_NAMESPACE::ClearColorValue & color, 11031 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT 11032 { 11033 getDispatcher()->vkCmdClearColorImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 11034 static_cast<VkImage>( image ), 11035 static_cast<VkImageLayout>( imageLayout ), 11036 reinterpret_cast<const VkClearColorValue *>( &color ), 11037 ranges.size(), 11038 reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) ); 11039 } 11040 clearDepthStencilImage(VULKAN_HPP_NAMESPACE::Image image,VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil,ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges) const11041 VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( 11042 VULKAN_HPP_NAMESPACE::Image image, 11043 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, 11044 const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil, 11045 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT 11046 { 11047 getDispatcher()->vkCmdClearDepthStencilImage( 11048 static_cast<VkCommandBuffer>( m_commandBuffer ), 11049 static_cast<VkImage>( image ), 11050 static_cast<VkImageLayout>( imageLayout ), 11051 reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ), 11052 ranges.size(), 11053 reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) ); 11054 } 11055 clearAttachments(ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects) const11056 VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( 11057 ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments, 11058 ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects ) const VULKAN_HPP_NOEXCEPT 11059 { 11060 getDispatcher()->vkCmdClearAttachments( static_cast<VkCommandBuffer>( m_commandBuffer ), 11061 attachments.size(), 11062 reinterpret_cast<const VkClearAttachment *>( attachments.data() ), 11063 rects.size(), 11064 reinterpret_cast<const VkClearRect *>( rects.data() ) ); 11065 } 11066 resolveImage(VULKAN_HPP_NAMESPACE::Image srcImage,VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,VULKAN_HPP_NAMESPACE::Image dstImage,VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions) const11067 VULKAN_HPP_INLINE void CommandBuffer::resolveImage( 11068 VULKAN_HPP_NAMESPACE::Image srcImage, 11069 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 11070 VULKAN_HPP_NAMESPACE::Image dstImage, 11071 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 11072 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT 11073 { 11074 getDispatcher()->vkCmdResolveImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 11075 static_cast<VkImage>( srcImage ), 11076 static_cast<VkImageLayout>( srcImageLayout ), 11077 static_cast<VkImage>( dstImage ), 11078 static_cast<VkImageLayout>( dstImageLayout ), 11079 regions.size(), 11080 reinterpret_cast<const VkImageResolve *>( regions.data() ) ); 11081 } 11082 11083 VULKAN_HPP_INLINE void setEvent(VULKAN_HPP_NAMESPACE::Event event,VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask) const11084 CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event event, 11085 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT 11086 { 11087 getDispatcher()->vkCmdSetEvent( static_cast<VkCommandBuffer>( m_commandBuffer ), 11088 static_cast<VkEvent>( event ), 11089 static_cast<VkPipelineStageFlags>( stageMask ) ); 11090 } 11091 11092 VULKAN_HPP_INLINE void resetEvent(VULKAN_HPP_NAMESPACE::Event event,VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask) const11093 CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event, 11094 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT 11095 { 11096 getDispatcher()->vkCmdResetEvent( static_cast<VkCommandBuffer>( m_commandBuffer ), 11097 static_cast<VkEvent>( event ), 11098 static_cast<VkPipelineStageFlags>( stageMask ) ); 11099 } 11100 waitEvents(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask,ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers) const11101 VULKAN_HPP_INLINE void CommandBuffer::waitEvents( 11102 ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 11103 VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, 11104 VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, 11105 ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, 11106 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, 11107 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT 11108 { 11109 getDispatcher()->vkCmdWaitEvents( static_cast<VkCommandBuffer>( m_commandBuffer ), 11110 events.size(), 11111 reinterpret_cast<const VkEvent *>( events.data() ), 11112 static_cast<VkPipelineStageFlags>( srcStageMask ), 11113 static_cast<VkPipelineStageFlags>( dstStageMask ), 11114 memoryBarriers.size(), 11115 reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ), 11116 bufferMemoryBarriers.size(), 11117 reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ), 11118 imageMemoryBarriers.size(), 11119 reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) ); 11120 } 11121 pipelineBarrier(VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask,VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers) const11122 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( 11123 VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, 11124 VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, 11125 VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, 11126 ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, 11127 ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, 11128 ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT 11129 { 11130 getDispatcher()->vkCmdPipelineBarrier( 11131 static_cast<VkCommandBuffer>( m_commandBuffer ), 11132 static_cast<VkPipelineStageFlags>( srcStageMask ), 11133 static_cast<VkPipelineStageFlags>( dstStageMask ), 11134 static_cast<VkDependencyFlags>( dependencyFlags ), 11135 memoryBarriers.size(), 11136 reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ), 11137 bufferMemoryBarriers.size(), 11138 reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ), 11139 imageMemoryBarriers.size(), 11140 reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) ); 11141 } 11142 11143 VULKAN_HPP_INLINE void beginQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query,VULKAN_HPP_NAMESPACE::QueryControlFlags flags) const11144 CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 11145 uint32_t query, 11146 VULKAN_HPP_NAMESPACE::QueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT 11147 { 11148 getDispatcher()->vkCmdBeginQuery( static_cast<VkCommandBuffer>( m_commandBuffer ), 11149 static_cast<VkQueryPool>( queryPool ), 11150 query, 11151 static_cast<VkQueryControlFlags>( flags ) ); 11152 } 11153 endQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query) const11154 VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 11155 uint32_t query ) const VULKAN_HPP_NOEXCEPT 11156 { 11157 getDispatcher()->vkCmdEndQuery( 11158 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query ); 11159 } 11160 resetQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const11161 VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 11162 uint32_t firstQuery, 11163 uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT 11164 { 11165 getDispatcher()->vkCmdResetQueryPool( static_cast<VkCommandBuffer>( m_commandBuffer ), 11166 static_cast<VkQueryPool>( queryPool ), 11167 firstQuery, 11168 queryCount ); 11169 } 11170 writeTimestamp(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query) const11171 VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, 11172 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 11173 uint32_t query ) const VULKAN_HPP_NOEXCEPT 11174 { 11175 getDispatcher()->vkCmdWriteTimestamp( static_cast<VkCommandBuffer>( m_commandBuffer ), 11176 static_cast<VkPipelineStageFlagBits>( pipelineStage ), 11177 static_cast<VkQueryPool>( queryPool ), 11178 query ); 11179 } 11180 11181 VULKAN_HPP_INLINE void copyQueryPoolResults(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,VULKAN_HPP_NAMESPACE::DeviceSize stride,VULKAN_HPP_NAMESPACE::QueryResultFlags flags) const11182 CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 11183 uint32_t firstQuery, 11184 uint32_t queryCount, 11185 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 11186 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 11187 VULKAN_HPP_NAMESPACE::DeviceSize stride, 11188 VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT 11189 { 11190 getDispatcher()->vkCmdCopyQueryPoolResults( static_cast<VkCommandBuffer>( m_commandBuffer ), 11191 static_cast<VkQueryPool>( queryPool ), 11192 firstQuery, 11193 queryCount, 11194 static_cast<VkBuffer>( dstBuffer ), 11195 static_cast<VkDeviceSize>( dstOffset ), 11196 static_cast<VkDeviceSize>( stride ), 11197 static_cast<VkQueryResultFlags>( flags ) ); 11198 } 11199 11200 template <typename T> pushConstants(VULKAN_HPP_NAMESPACE::PipelineLayout layout,VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,uint32_t offset,ArrayProxy<const T> const & values) const11201 VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, 11202 VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, 11203 uint32_t offset, 11204 ArrayProxy<const T> const & values ) const VULKAN_HPP_NOEXCEPT 11205 { 11206 getDispatcher()->vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), 11207 static_cast<VkPipelineLayout>( layout ), 11208 static_cast<VkShaderStageFlags>( stageFlags ), 11209 offset, 11210 values.size() * sizeof( T ), 11211 reinterpret_cast<const void *>( values.data() ) ); 11212 } 11213 11214 VULKAN_HPP_INLINE void beginRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,VULKAN_HPP_NAMESPACE::SubpassContents contents) const11215 CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 11216 VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT 11217 { 11218 getDispatcher()->vkCmdBeginRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ), 11219 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), 11220 static_cast<VkSubpassContents>( contents ) ); 11221 } 11222 11223 VULKAN_HPP_INLINE void nextSubpass(VULKAN_HPP_NAMESPACE::SubpassContents contents) const11224 CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT 11225 { 11226 getDispatcher()->vkCmdNextSubpass( static_cast<VkCommandBuffer>( m_commandBuffer ), 11227 static_cast<VkSubpassContents>( contents ) ); 11228 } 11229 endRenderPass() const11230 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const VULKAN_HPP_NOEXCEPT 11231 { 11232 getDispatcher()->vkCmdEndRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 11233 } 11234 executeCommands(ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers) const11235 VULKAN_HPP_INLINE void CommandBuffer::executeCommands( 11236 ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const VULKAN_HPP_NOEXCEPT 11237 { 11238 getDispatcher()->vkCmdExecuteCommands( static_cast<VkCommandBuffer>( m_commandBuffer ), 11239 commandBuffers.size(), 11240 reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) ); 11241 } 11242 11243 //=== VK_VERSION_1_1 === 11244 enumerateInstanceVersion() const11245 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t Context::enumerateInstanceVersion() const 11246 { 11247 uint32_t apiVersion; 11248 VULKAN_HPP_NAMESPACE::Result result = 11249 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceVersion( &apiVersion ) ); 11250 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11251 { 11252 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceVersion" ); 11253 } 11254 return apiVersion; 11255 } 11256 11257 VULKAN_HPP_INLINE void bindBufferMemory2(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos) const11258 Device::bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const 11259 { 11260 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 11261 getDispatcher()->vkBindBufferMemory2( static_cast<VkDevice>( m_device ), 11262 bindInfos.size(), 11263 reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) ); 11264 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11265 { 11266 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" ); 11267 } 11268 } 11269 11270 VULKAN_HPP_INLINE void bindImageMemory2(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos) const11271 Device::bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const 11272 { 11273 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 11274 getDispatcher()->vkBindImageMemory2( static_cast<VkDevice>( m_device ), 11275 bindInfos.size(), 11276 reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) ); 11277 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11278 { 11279 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" ); 11280 } 11281 } 11282 11283 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex) const11284 Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, 11285 uint32_t localDeviceIndex, 11286 uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT 11287 { 11288 VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; 11289 getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures( 11290 static_cast<VkDevice>( m_device ), 11291 heapIndex, 11292 localDeviceIndex, 11293 remoteDeviceIndex, 11294 reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) ); 11295 return peerMemoryFeatures; 11296 } 11297 setDeviceMask(uint32_t deviceMask) const11298 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT 11299 { 11300 getDispatcher()->vkCmdSetDeviceMask( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask ); 11301 } 11302 dispatchBase(uint32_t baseGroupX,uint32_t baseGroupY,uint32_t baseGroupZ,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const11303 VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, 11304 uint32_t baseGroupY, 11305 uint32_t baseGroupZ, 11306 uint32_t groupCountX, 11307 uint32_t groupCountY, 11308 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 11309 { 11310 getDispatcher()->vkCmdDispatchBase( static_cast<VkCommandBuffer>( m_commandBuffer ), 11311 baseGroupX, 11312 baseGroupY, 11313 baseGroupZ, 11314 groupCountX, 11315 groupCountY, 11316 groupCountZ ); 11317 } 11318 11319 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroups() const11320 Instance::enumeratePhysicalDeviceGroups() const 11321 { 11322 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties; 11323 uint32_t physicalDeviceGroupCount; 11324 VULKAN_HPP_NAMESPACE::Result result; 11325 do 11326 { 11327 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroups( 11328 static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) ); 11329 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount ) 11330 { 11331 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); 11332 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroups( 11333 static_cast<VkInstance>( m_instance ), 11334 &physicalDeviceGroupCount, 11335 reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); 11336 } 11337 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 11338 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11339 { 11340 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); 11341 } 11342 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11343 { 11344 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); 11345 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) 11346 { 11347 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); 11348 } 11349 } 11350 return physicalDeviceGroupProperties; 11351 } 11352 11353 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info) const11354 Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const 11355 VULKAN_HPP_NOEXCEPT 11356 { 11357 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 11358 getDispatcher()->vkGetImageMemoryRequirements2( 11359 static_cast<VkDevice>( m_device ), 11360 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), 11361 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 11362 return memoryRequirements; 11363 } 11364 11365 template <typename X, typename Y, typename... Z> getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info) const11366 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2( 11367 const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 11368 { 11369 StructureChain<X, Y, Z...> structureChain; 11370 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = 11371 structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 11372 getDispatcher()->vkGetImageMemoryRequirements2( 11373 static_cast<VkDevice>( m_device ), 11374 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), 11375 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 11376 return structureChain; 11377 } 11378 11379 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info) const11380 Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const 11381 VULKAN_HPP_NOEXCEPT 11382 { 11383 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 11384 getDispatcher()->vkGetBufferMemoryRequirements2( 11385 static_cast<VkDevice>( m_device ), 11386 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), 11387 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 11388 return memoryRequirements; 11389 } 11390 11391 template <typename X, typename Y, typename... Z> getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info) const11392 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2( 11393 const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 11394 { 11395 StructureChain<X, Y, Z...> structureChain; 11396 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = 11397 structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 11398 getDispatcher()->vkGetBufferMemoryRequirements2( 11399 static_cast<VkDevice>( m_device ), 11400 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), 11401 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 11402 return structureChain; 11403 } 11404 11405 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info) const11406 Device::getImageSparseMemoryRequirements2( 11407 const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 11408 { 11409 uint32_t sparseMemoryRequirementCount; 11410 getDispatcher()->vkGetImageSparseMemoryRequirements2( 11411 static_cast<VkDevice>( m_device ), 11412 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), 11413 &sparseMemoryRequirementCount, 11414 nullptr ); 11415 std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements( 11416 sparseMemoryRequirementCount ); 11417 getDispatcher()->vkGetImageSparseMemoryRequirements2( 11418 static_cast<VkDevice>( m_device ), 11419 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), 11420 &sparseMemoryRequirementCount, 11421 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); 11422 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount == sparseMemoryRequirements.size() ); 11423 return sparseMemoryRequirements; 11424 } 11425 11426 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2() const11427 PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT 11428 { 11429 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; 11430 getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 11431 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); 11432 return features; 11433 } 11434 11435 template <typename X, typename Y, typename... Z> 11436 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> getFeatures2() const11437 PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT 11438 { 11439 StructureChain<X, Y, Z...> structureChain; 11440 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = 11441 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); 11442 getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 11443 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); 11444 return structureChain; 11445 } 11446 11447 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2() const11448 PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT 11449 { 11450 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; 11451 getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 11452 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); 11453 return properties; 11454 } 11455 11456 template <typename X, typename Y, typename... Z> 11457 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> getProperties2() const11458 PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT 11459 { 11460 StructureChain<X, Y, Z...> structureChain; 11461 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = 11462 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); 11463 getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 11464 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); 11465 return structureChain; 11466 } 11467 11468 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format) const11469 PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 11470 { 11471 VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; 11472 getDispatcher()->vkGetPhysicalDeviceFormatProperties2( 11473 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11474 static_cast<VkFormat>( format ), 11475 reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); 11476 return formatProperties; 11477 } 11478 11479 template <typename X, typename Y, typename... Z> 11480 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format) const11481 PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 11482 { 11483 StructureChain<X, Y, Z...> structureChain; 11484 VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = 11485 structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); 11486 getDispatcher()->vkGetPhysicalDeviceFormatProperties2( 11487 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11488 static_cast<VkFormat>( format ), 11489 reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); 11490 return structureChain; 11491 } 11492 11493 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2 getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo) const11494 PhysicalDevice::getImageFormatProperties2( 11495 const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const 11496 { 11497 VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; 11498 VULKAN_HPP_NAMESPACE::Result result = 11499 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( 11500 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11501 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), 11502 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); 11503 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11504 { 11505 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); 11506 } 11507 return imageFormatProperties; 11508 } 11509 11510 template <typename X, typename Y, typename... Z> getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo) const11511 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> PhysicalDevice::getImageFormatProperties2( 11512 const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const 11513 { 11514 StructureChain<X, Y, Z...> structureChain; 11515 VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = 11516 structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); 11517 VULKAN_HPP_NAMESPACE::Result result = 11518 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( 11519 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11520 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), 11521 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); 11522 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11523 { 11524 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); 11525 } 11526 return structureChain; 11527 } 11528 11529 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2() const11530 PhysicalDevice::getQueueFamilyProperties2() const VULKAN_HPP_NOEXCEPT 11531 { 11532 uint32_t queueFamilyPropertyCount; 11533 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( 11534 static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 11535 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); 11536 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( 11537 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11538 &queueFamilyPropertyCount, 11539 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); 11540 VULKAN_HPP_ASSERT( queueFamilyPropertyCount == queueFamilyProperties.size() ); 11541 return queueFamilyProperties; 11542 } 11543 11544 template <typename StructureChain> getQueueFamilyProperties2() const11545 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2() const 11546 { 11547 uint32_t queueFamilyPropertyCount; 11548 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( 11549 static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 11550 std::vector<StructureChain> returnVector( queueFamilyPropertyCount ); 11551 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); 11552 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) 11553 { 11554 queueFamilyProperties[i].pNext = 11555 returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; 11556 } 11557 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( 11558 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11559 &queueFamilyPropertyCount, 11560 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); 11561 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); 11562 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) 11563 { 11564 returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; 11565 } 11566 return returnVector; 11567 } 11568 11569 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2() const11570 PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT 11571 { 11572 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; 11573 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( 11574 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11575 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); 11576 return memoryProperties; 11577 } 11578 11579 template <typename X, typename Y, typename... Z> 11580 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> getMemoryProperties2() const11581 PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT 11582 { 11583 StructureChain<X, Y, Z...> structureChain; 11584 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = 11585 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); 11586 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( 11587 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11588 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); 11589 return structureChain; 11590 } 11591 11592 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo) const11593 PhysicalDevice::getSparseImageFormatProperties2( 11594 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const VULKAN_HPP_NOEXCEPT 11595 { 11596 uint32_t propertyCount; 11597 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( 11598 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11599 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), 11600 &propertyCount, 11601 nullptr ); 11602 std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties( propertyCount ); 11603 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( 11604 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11605 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), 11606 &propertyCount, 11607 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); 11608 VULKAN_HPP_ASSERT( propertyCount == properties.size() ); 11609 return properties; 11610 } 11611 11612 VULKAN_HPP_INLINE void trim(VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags) const11613 CommandPool::trim( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT 11614 { 11615 getDispatcher()->vkTrimCommandPool( static_cast<VkDevice>( m_device ), 11616 static_cast<VkCommandPool>( m_commandPool ), 11617 static_cast<VkCommandPoolTrimFlags>( flags ) ); 11618 } 11619 11620 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Queue getQueue2(VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo) const11621 Device::getQueue2( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) const 11622 { 11623 return VULKAN_HPP_RAII_NAMESPACE::Queue( *this, queueInfo ); 11624 } 11625 11626 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion createSamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const11627 Device::createSamplerYcbcrConversion( 11628 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 11629 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 11630 { 11631 return VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion( *this, createInfo, allocator ); 11632 } 11633 11634 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate createDescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const11635 Device::createDescriptorUpdateTemplate( 11636 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 11637 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 11638 { 11639 return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( *this, createInfo, allocator ); 11640 } 11641 11642 VULKAN_HPP_INLINE void updateWithTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,const void * pData) const11643 DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 11644 const void * pData ) const VULKAN_HPP_NOEXCEPT 11645 { 11646 getDispatcher()->vkUpdateDescriptorSetWithTemplate( 11647 static_cast<VkDevice>( m_device ), 11648 static_cast<VkDescriptorSet>( m_descriptorSet ), 11649 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), 11650 pData ); 11651 } 11652 11653 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo) const11654 PhysicalDevice::getExternalBufferProperties( 11655 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT 11656 { 11657 VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; 11658 getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties( 11659 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11660 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ), 11661 reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) ); 11662 return externalBufferProperties; 11663 } 11664 11665 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo) const11666 PhysicalDevice::getExternalFenceProperties( 11667 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT 11668 { 11669 VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; 11670 getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties( 11671 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11672 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ), 11673 reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) ); 11674 return externalFenceProperties; 11675 } 11676 11677 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo) const11678 PhysicalDevice::getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & 11679 externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT 11680 { 11681 VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; 11682 getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties( 11683 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11684 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ), 11685 reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) ); 11686 return externalSemaphoreProperties; 11687 } 11688 11689 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo) const11690 Device::getDescriptorSetLayoutSupport( 11691 const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 11692 { 11693 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; 11694 getDispatcher()->vkGetDescriptorSetLayoutSupport( 11695 static_cast<VkDevice>( m_device ), 11696 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 11697 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); 11698 return support; 11699 } 11700 11701 template <typename X, typename Y, typename... Z> getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo) const11702 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupport( 11703 const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 11704 { 11705 StructureChain<X, Y, Z...> structureChain; 11706 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = 11707 structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); 11708 getDispatcher()->vkGetDescriptorSetLayoutSupport( 11709 static_cast<VkDevice>( m_device ), 11710 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 11711 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); 11712 return structureChain; 11713 } 11714 11715 //=== VK_VERSION_1_2 === 11716 drawIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::Buffer countBuffer,VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const11717 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, 11718 VULKAN_HPP_NAMESPACE::DeviceSize offset, 11719 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 11720 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 11721 uint32_t maxDrawCount, 11722 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 11723 { 11724 getDispatcher()->vkCmdDrawIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ), 11725 static_cast<VkBuffer>( buffer ), 11726 static_cast<VkDeviceSize>( offset ), 11727 static_cast<VkBuffer>( countBuffer ), 11728 static_cast<VkDeviceSize>( countBufferOffset ), 11729 maxDrawCount, 11730 stride ); 11731 } 11732 drawIndexedIndirectCount(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::Buffer countBuffer,VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const11733 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, 11734 VULKAN_HPP_NAMESPACE::DeviceSize offset, 11735 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 11736 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 11737 uint32_t maxDrawCount, 11738 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 11739 { 11740 getDispatcher()->vkCmdDrawIndexedIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ), 11741 static_cast<VkBuffer>( buffer ), 11742 static_cast<VkDeviceSize>( offset ), 11743 static_cast<VkBuffer>( countBuffer ), 11744 static_cast<VkDeviceSize>( countBufferOffset ), 11745 maxDrawCount, 11746 stride ); 11747 } 11748 createRenderPass2(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const11749 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::RenderPass Device::createRenderPass2( 11750 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 11751 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 11752 { 11753 return VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, createInfo, allocator ); 11754 } 11755 beginRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo) const11756 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( 11757 const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 11758 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 11759 { 11760 getDispatcher()->vkCmdBeginRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ), 11761 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), 11762 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) ); 11763 } 11764 nextSubpass2(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo) const11765 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( 11766 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, 11767 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 11768 { 11769 getDispatcher()->vkCmdNextSubpass2( static_cast<VkCommandBuffer>( m_commandBuffer ), 11770 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), 11771 reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); 11772 } 11773 endRenderPass2(const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo) const11774 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( 11775 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 11776 { 11777 getDispatcher()->vkCmdEndRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ), 11778 reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); 11779 } 11780 reset(uint32_t firstQuery,uint32_t queryCount) const11781 VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT 11782 { 11783 getDispatcher()->vkResetQueryPool( 11784 static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount ); 11785 } 11786 getCounterValue() const11787 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValue() const 11788 { 11789 uint64_t value; 11790 VULKAN_HPP_NAMESPACE::Result result = 11791 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreCounterValue( 11792 static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) ); 11793 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11794 { 11795 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" ); 11796 } 11797 return value; 11798 } 11799 11800 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result waitSemaphores(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,uint64_t timeout) const11801 Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const 11802 { 11803 VULKAN_HPP_NAMESPACE::Result result = 11804 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitSemaphores( 11805 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) ); 11806 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 11807 ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) ) 11808 { 11809 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores" ); 11810 } 11811 return result; 11812 } 11813 signalSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo) const11814 VULKAN_HPP_INLINE void Device::signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const 11815 { 11816 VULKAN_HPP_NAMESPACE::Result result = 11817 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSignalSemaphore( 11818 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) ); 11819 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11820 { 11821 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" ); 11822 } 11823 } 11824 11825 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const11826 Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 11827 { 11828 return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( getDispatcher()->vkGetBufferDeviceAddress( 11829 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ) ); 11830 } 11831 getBufferOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const11832 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( 11833 const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 11834 { 11835 return getDispatcher()->vkGetBufferOpaqueCaptureAddress( 11836 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); 11837 } 11838 getMemoryOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info) const11839 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( 11840 const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 11841 { 11842 return getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress( 11843 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) ); 11844 } 11845 11846 //=== VK_KHR_surface === 11847 11848 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getSurfaceSupportKHR(uint32_t queueFamilyIndex,VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const11849 PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 11850 { 11851 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR && 11852 "Function <vkGetPhysicalDeviceSurfaceSupportKHR> needs extension <VK_KHR_surface> enabled!" ); 11853 11854 VULKAN_HPP_NAMESPACE::Bool32 supported; 11855 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 11856 getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 11857 queueFamilyIndex, 11858 static_cast<VkSurfaceKHR>( surface ), 11859 reinterpret_cast<VkBool32 *>( &supported ) ) ); 11860 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11861 { 11862 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); 11863 } 11864 return supported; 11865 } 11866 11867 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR getSurfaceCapabilitiesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const11868 PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 11869 { 11870 VULKAN_HPP_ASSERT( 11871 getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR && 11872 "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> needs extension <VK_KHR_surface> enabled!" ); 11873 11874 VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities; 11875 VULKAN_HPP_NAMESPACE::Result result = 11876 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 11877 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11878 static_cast<VkSurfaceKHR>( surface ), 11879 reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) ); 11880 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11881 { 11882 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); 11883 } 11884 return surfaceCapabilities; 11885 } 11886 11887 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> getSurfaceFormatsKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const11888 PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 11889 { 11890 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR && 11891 "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> needs extension <VK_KHR_surface> enabled!" ); 11892 11893 std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> surfaceFormats; 11894 uint32_t surfaceFormatCount; 11895 VULKAN_HPP_NAMESPACE::Result result; 11896 do 11897 { 11898 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 11899 getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 11900 static_cast<VkSurfaceKHR>( surface ), 11901 &surfaceFormatCount, 11902 nullptr ) ); 11903 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) 11904 { 11905 surfaceFormats.resize( surfaceFormatCount ); 11906 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( 11907 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11908 static_cast<VkSurfaceKHR>( surface ), 11909 &surfaceFormatCount, 11910 reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) ); 11911 } 11912 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 11913 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11914 { 11915 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); 11916 } 11917 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11918 { 11919 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); 11920 if ( surfaceFormatCount < surfaceFormats.size() ) 11921 { 11922 surfaceFormats.resize( surfaceFormatCount ); 11923 } 11924 } 11925 return surfaceFormats; 11926 } 11927 11928 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> getSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const11929 PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 11930 { 11931 VULKAN_HPP_ASSERT( 11932 getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR && 11933 "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> needs extension <VK_KHR_surface> enabled!" ); 11934 11935 std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes; 11936 uint32_t presentModeCount; 11937 VULKAN_HPP_NAMESPACE::Result result; 11938 do 11939 { 11940 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 11941 getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 11942 static_cast<VkSurfaceKHR>( surface ), 11943 &presentModeCount, 11944 nullptr ) ); 11945 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount ) 11946 { 11947 presentModes.resize( presentModeCount ); 11948 result = 11949 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( 11950 static_cast<VkPhysicalDevice>( m_physicalDevice ), 11951 static_cast<VkSurfaceKHR>( surface ), 11952 &presentModeCount, 11953 reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); 11954 } 11955 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 11956 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11957 { 11958 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); 11959 } 11960 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11961 { 11962 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); 11963 if ( presentModeCount < presentModes.size() ) 11964 { 11965 presentModes.resize( presentModeCount ); 11966 } 11967 } 11968 return presentModes; 11969 } 11970 11971 //=== VK_KHR_swapchain === 11972 createSwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const11973 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR Device::createSwapchainKHR( 11974 VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 11975 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 11976 { 11977 return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, createInfo, allocator ); 11978 } 11979 getImages() const11980 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VkImage> SwapchainKHR::getImages() const 11981 { 11982 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainImagesKHR && 11983 "Function <vkGetSwapchainImagesKHR> needs extension <VK_KHR_swapchain> enabled!" ); 11984 11985 std::vector<VkImage> swapchainImages; 11986 uint32_t swapchainImageCount; 11987 VULKAN_HPP_NAMESPACE::Result result; 11988 do 11989 { 11990 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 11991 getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ), 11992 static_cast<VkSwapchainKHR>( m_swapchain ), 11993 &swapchainImageCount, 11994 nullptr ) ); 11995 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount ) 11996 { 11997 swapchainImages.resize( swapchainImageCount ); 11998 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 11999 getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ), 12000 static_cast<VkSwapchainKHR>( m_swapchain ), 12001 &swapchainImageCount, 12002 swapchainImages.data() ) ); 12003 } 12004 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12005 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12006 { 12007 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getImages" ); 12008 } 12009 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12010 { 12011 VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); 12012 if ( swapchainImageCount < swapchainImages.size() ) 12013 { 12014 swapchainImages.resize( swapchainImageCount ); 12015 } 12016 } 12017 return swapchainImages; 12018 } 12019 12020 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> acquireNextImage(uint64_t timeout,VULKAN_HPP_NAMESPACE::Semaphore semaphore,VULKAN_HPP_NAMESPACE::Fence fence) const12021 SwapchainKHR::acquireNextImage( uint64_t timeout, 12022 VULKAN_HPP_NAMESPACE::Semaphore semaphore, 12023 VULKAN_HPP_NAMESPACE::Fence fence ) const 12024 { 12025 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImageKHR && 12026 "Function <vkAcquireNextImageKHR> needs extension <VK_KHR_swapchain> enabled!" ); 12027 12028 uint32_t imageIndex; 12029 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12030 getDispatcher()->vkAcquireNextImageKHR( static_cast<VkDevice>( m_device ), 12031 static_cast<VkSwapchainKHR>( m_swapchain ), 12032 timeout, 12033 static_cast<VkSemaphore>( semaphore ), 12034 static_cast<VkFence>( fence ), 12035 &imageIndex ) ); 12036 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 12037 ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) && 12038 ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) && 12039 ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) ) 12040 { 12041 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage" ); 12042 } 12043 return std::make_pair( result, imageIndex ); 12044 } 12045 12046 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result presentKHR(const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo) const12047 Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo ) const 12048 { 12049 VULKAN_HPP_ASSERT( getDispatcher()->vkQueuePresentKHR && 12050 "Function <vkQueuePresentKHR> needs extension <VK_KHR_swapchain> enabled!" ); 12051 12052 VULKAN_HPP_NAMESPACE::Result result = 12053 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueuePresentKHR( 12054 static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) ); 12055 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 12056 ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) ) 12057 { 12058 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR" ); 12059 } 12060 return result; 12061 } 12062 12063 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR getGroupPresentCapabilitiesKHR() const12064 Device::getGroupPresentCapabilitiesKHR() const 12065 { 12066 VULKAN_HPP_ASSERT( 12067 getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR && 12068 "Function <vkGetDeviceGroupPresentCapabilitiesKHR> needs extension <VK_KHR_swapchain> enabled!" ); 12069 12070 VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; 12071 VULKAN_HPP_NAMESPACE::Result result = 12072 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR( 12073 static_cast<VkDevice>( m_device ), 12074 reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) ); 12075 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12076 { 12077 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); 12078 } 12079 return deviceGroupPresentCapabilities; 12080 } 12081 12082 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR getGroupSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const12083 Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 12084 { 12085 VULKAN_HPP_ASSERT( 12086 getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR && 12087 "Function <vkGetDeviceGroupSurfacePresentModesKHR> needs extension <VK_KHR_swapchain> enabled!" ); 12088 12089 VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; 12090 VULKAN_HPP_NAMESPACE::Result result = 12091 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR( 12092 static_cast<VkDevice>( m_device ), 12093 static_cast<VkSurfaceKHR>( surface ), 12094 reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) ); 12095 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12096 { 12097 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); 12098 } 12099 return modes; 12100 } 12101 12102 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Rect2D> getPresentRectanglesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const12103 PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 12104 { 12105 VULKAN_HPP_ASSERT( 12106 getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR && 12107 "Function <vkGetPhysicalDevicePresentRectanglesKHR> needs extension <VK_KHR_swapchain> enabled!" ); 12108 12109 std::vector<VULKAN_HPP_NAMESPACE::Rect2D> rects; 12110 uint32_t rectCount; 12111 VULKAN_HPP_NAMESPACE::Result result; 12112 do 12113 { 12114 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12115 getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12116 static_cast<VkSurfaceKHR>( surface ), 12117 &rectCount, 12118 nullptr ) ); 12119 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && rectCount ) 12120 { 12121 rects.resize( rectCount ); 12122 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12123 getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12124 static_cast<VkSurfaceKHR>( surface ), 12125 &rectCount, 12126 reinterpret_cast<VkRect2D *>( rects.data() ) ) ); 12127 } 12128 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12129 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12130 { 12131 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); 12132 } 12133 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12134 { 12135 VULKAN_HPP_ASSERT( rectCount <= rects.size() ); 12136 if ( rectCount < rects.size() ) 12137 { 12138 rects.resize( rectCount ); 12139 } 12140 } 12141 return rects; 12142 } 12143 12144 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> acquireNextImage2KHR(const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo) const12145 Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo ) const 12146 { 12147 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImage2KHR && 12148 "Function <vkAcquireNextImage2KHR> needs extension <VK_KHR_swapchain> enabled!" ); 12149 12150 uint32_t imageIndex; 12151 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12152 getDispatcher()->vkAcquireNextImage2KHR( static_cast<VkDevice>( m_device ), 12153 reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ), 12154 &imageIndex ) ); 12155 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 12156 ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) && 12157 ( result != VULKAN_HPP_NAMESPACE::Result::eNotReady ) && 12158 ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) ) 12159 { 12160 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR" ); 12161 } 12162 return std::make_pair( result, imageIndex ); 12163 } 12164 12165 //=== VK_KHR_display === 12166 12167 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> getDisplayPropertiesKHR() const12168 PhysicalDevice::getDisplayPropertiesKHR() const 12169 { 12170 VULKAN_HPP_ASSERT( 12171 getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR && 12172 "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> needs extension <VK_KHR_display> enabled!" ); 12173 12174 std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> properties; 12175 uint32_t propertyCount; 12176 VULKAN_HPP_NAMESPACE::Result result; 12177 do 12178 { 12179 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( 12180 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 12181 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 12182 { 12183 properties.resize( propertyCount ); 12184 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( 12185 static_cast<VkPhysicalDevice>( m_physicalDevice ), 12186 &propertyCount, 12187 reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) ); 12188 } 12189 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12190 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12191 { 12192 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); 12193 } 12194 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12195 { 12196 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 12197 if ( propertyCount < properties.size() ) 12198 { 12199 properties.resize( propertyCount ); 12200 } 12201 } 12202 return properties; 12203 } 12204 12205 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> getDisplayPlanePropertiesKHR() const12206 PhysicalDevice::getDisplayPlanePropertiesKHR() const 12207 { 12208 VULKAN_HPP_ASSERT( 12209 getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR && 12210 "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> needs extension <VK_KHR_display> enabled!" ); 12211 12212 std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> properties; 12213 uint32_t propertyCount; 12214 VULKAN_HPP_NAMESPACE::Result result; 12215 do 12216 { 12217 result = 12218 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 12219 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 12220 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 12221 { 12222 properties.resize( propertyCount ); 12223 result = 12224 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 12225 static_cast<VkPhysicalDevice>( m_physicalDevice ), 12226 &propertyCount, 12227 reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) ); 12228 } 12229 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12230 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12231 { 12232 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); 12233 } 12234 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12235 { 12236 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 12237 if ( propertyCount < properties.size() ) 12238 { 12239 properties.resize( propertyCount ); 12240 } 12241 } 12242 return properties; 12243 } 12244 12245 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex) const12246 PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const 12247 { 12248 return VULKAN_HPP_RAII_NAMESPACE::DisplayKHRs( *this, planeIndex ); 12249 } 12250 12251 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const12252 DisplayKHR::getModeProperties() const 12253 { 12254 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModePropertiesKHR && 12255 "Function <vkGetDisplayModePropertiesKHR> needs extension <VK_KHR_display> enabled!" ); 12256 12257 std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> properties; 12258 uint32_t propertyCount; 12259 VULKAN_HPP_NAMESPACE::Result result; 12260 do 12261 { 12262 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12263 getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12264 static_cast<VkDisplayKHR>( m_display ), 12265 &propertyCount, 12266 nullptr ) ); 12267 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 12268 { 12269 properties.resize( propertyCount ); 12270 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModePropertiesKHR( 12271 static_cast<VkPhysicalDevice>( m_physicalDevice ), 12272 static_cast<VkDisplayKHR>( m_display ), 12273 &propertyCount, 12274 reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) ); 12275 } 12276 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12277 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12278 { 12279 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties" ); 12280 } 12281 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12282 { 12283 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 12284 if ( propertyCount < properties.size() ) 12285 { 12286 properties.resize( propertyCount ); 12287 } 12288 } 12289 return properties; 12290 } 12291 createMode(VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12292 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR DisplayKHR::createMode( 12293 VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, 12294 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12295 { 12296 return VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR( *this, createInfo, allocator ); 12297 } 12298 12299 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR getDisplayPlaneCapabilities(uint32_t planeIndex) const12300 DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex ) const 12301 { 12302 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR && 12303 "Function <vkGetDisplayPlaneCapabilitiesKHR> needs extension <VK_KHR_display> enabled!" ); 12304 12305 VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities; 12306 VULKAN_HPP_NAMESPACE::Result result = 12307 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR( 12308 static_cast<VkPhysicalDevice>( m_physicalDevice ), 12309 static_cast<VkDisplayModeKHR>( m_displayModeKHR ), 12310 planeIndex, 12311 reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) ); 12312 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12313 { 12314 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" ); 12315 } 12316 return capabilities; 12317 } 12318 createDisplayPlaneSurfaceKHR(VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12319 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createDisplayPlaneSurfaceKHR( 12320 VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo, 12321 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12322 { 12323 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 12324 } 12325 12326 //=== VK_KHR_display_swapchain === 12327 12328 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> createSharedSwapchainsKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12329 Device::createSharedSwapchainsKHR( 12330 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, 12331 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12332 { 12333 return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHRs( *this, createInfos, allocator ); 12334 } 12335 createSharedSwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12336 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR Device::createSharedSwapchainKHR( 12337 VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 12338 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12339 { 12340 return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, createInfo, allocator ); 12341 } 12342 12343 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 12344 //=== VK_KHR_xlib_surface === 12345 createXlibSurfaceKHR(VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12346 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createXlibSurfaceKHR( 12347 VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo, 12348 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12349 { 12350 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 12351 } 12352 getXlibPresentationSupportKHR(uint32_t queueFamilyIndex,Display & dpy,VisualID visualID) const12353 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXlibPresentationSupportKHR( 12354 uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT 12355 { 12356 VULKAN_HPP_ASSERT( 12357 getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR && 12358 "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> needs extension <VK_KHR_xlib_surface> enabled!" ); 12359 12360 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR( 12361 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dpy, visualID ) ); 12362 } 12363 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 12364 12365 # if defined( VK_USE_PLATFORM_XCB_KHR ) 12366 //=== VK_KHR_xcb_surface === 12367 createXcbSurfaceKHR(VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12368 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createXcbSurfaceKHR( 12369 VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo, 12370 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12371 { 12372 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 12373 } 12374 getXcbPresentationSupportKHR(uint32_t queueFamilyIndex,xcb_connection_t & connection,xcb_visualid_t visual_id) const12375 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR( 12376 uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT 12377 { 12378 VULKAN_HPP_ASSERT( 12379 getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR && 12380 "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> needs extension <VK_KHR_xcb_surface> enabled!" ); 12381 12382 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR( 12383 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &connection, visual_id ) ); 12384 } 12385 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 12386 12387 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 12388 //=== VK_KHR_wayland_surface === 12389 createWaylandSurfaceKHR(VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12390 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createWaylandSurfaceKHR( 12391 VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo, 12392 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12393 { 12394 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 12395 } 12396 12397 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR(uint32_t queueFamilyIndex,struct wl_display & display) const12398 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, 12399 struct wl_display & display ) const VULKAN_HPP_NOEXCEPT 12400 { 12401 VULKAN_HPP_ASSERT( 12402 getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR && 12403 "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> needs extension <VK_KHR_wayland_surface> enabled!" ); 12404 12405 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( 12406 getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR( 12407 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &display ) ); 12408 } 12409 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 12410 12411 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 12412 //=== VK_KHR_android_surface === 12413 createAndroidSurfaceKHR(VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12414 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createAndroidSurfaceKHR( 12415 VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo, 12416 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12417 { 12418 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 12419 } 12420 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 12421 12422 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 12423 //=== VK_KHR_win32_surface === 12424 createWin32SurfaceKHR(VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12425 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createWin32SurfaceKHR( 12426 VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo, 12427 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12428 { 12429 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 12430 } 12431 12432 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getWin32PresentationSupportKHR(uint32_t queueFamilyIndex) const12433 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT 12434 { 12435 VULKAN_HPP_ASSERT( 12436 getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR && 12437 "Function <vkGetPhysicalDeviceWin32PresentationSupportKHR> needs extension <VK_KHR_win32_surface> enabled!" ); 12438 12439 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR( 12440 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex ) ); 12441 } 12442 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 12443 12444 //=== VK_EXT_debug_report === 12445 12446 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT createDebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12447 Instance::createDebugReportCallbackEXT( 12448 VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo, 12449 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12450 { 12451 return VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT( *this, createInfo, allocator ); 12452 } 12453 debugReportMessageEXT(VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags,VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,uint64_t object,size_t location,int32_t messageCode,const std::string & layerPrefix,const std::string & message) const12454 VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, 12455 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, 12456 uint64_t object, 12457 size_t location, 12458 int32_t messageCode, 12459 const std::string & layerPrefix, 12460 const std::string & message ) const VULKAN_HPP_NOEXCEPT 12461 { 12462 VULKAN_HPP_ASSERT( getDispatcher()->vkDebugReportMessageEXT && 12463 "Function <vkDebugReportMessageEXT> needs extension <VK_EXT_debug_report> enabled!" ); 12464 12465 getDispatcher()->vkDebugReportMessageEXT( static_cast<VkInstance>( m_instance ), 12466 static_cast<VkDebugReportFlagsEXT>( flags ), 12467 static_cast<VkDebugReportObjectTypeEXT>( objectType_ ), 12468 object, 12469 location, 12470 messageCode, 12471 layerPrefix.c_str(), 12472 message.c_str() ); 12473 } 12474 12475 //=== VK_EXT_debug_marker === 12476 12477 VULKAN_HPP_INLINE void debugMarkerSetObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo) const12478 Device::debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo ) const 12479 { 12480 VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectTagEXT && 12481 "Function <vkDebugMarkerSetObjectTagEXT> needs extension <VK_EXT_debug_marker> enabled!" ); 12482 12483 VULKAN_HPP_NAMESPACE::Result result = 12484 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectTagEXT( 12485 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) ); 12486 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12487 { 12488 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); 12489 } 12490 } 12491 12492 VULKAN_HPP_INLINE void debugMarkerSetObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo) const12493 Device::debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo ) const 12494 { 12495 VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectNameEXT && 12496 "Function <vkDebugMarkerSetObjectNameEXT> needs extension <VK_EXT_debug_marker> enabled!" ); 12497 12498 VULKAN_HPP_NAMESPACE::Result result = 12499 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectNameEXT( 12500 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) ); 12501 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12502 { 12503 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); 12504 } 12505 } 12506 debugMarkerBeginEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo) const12507 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( 12508 const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT 12509 { 12510 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerBeginEXT && 12511 "Function <vkCmdDebugMarkerBeginEXT> needs extension <VK_EXT_debug_marker> enabled!" ); 12512 12513 getDispatcher()->vkCmdDebugMarkerBeginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 12514 reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) ); 12515 } 12516 debugMarkerEndEXT() const12517 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT 12518 { 12519 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerEndEXT && 12520 "Function <vkCmdDebugMarkerEndEXT> needs extension <VK_EXT_debug_marker> enabled!" ); 12521 12522 getDispatcher()->vkCmdDebugMarkerEndEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 12523 } 12524 debugMarkerInsertEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo) const12525 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( 12526 const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT 12527 { 12528 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerInsertEXT && 12529 "Function <vkCmdDebugMarkerInsertEXT> needs extension <VK_EXT_debug_marker> enabled!" ); 12530 12531 getDispatcher()->vkCmdDebugMarkerInsertEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 12532 reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) ); 12533 } 12534 12535 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 12536 //=== VK_KHR_video_queue === 12537 12538 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile) const12539 PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile ) const 12540 { 12541 VULKAN_HPP_ASSERT( 12542 getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && 12543 "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> needs extension <VK_KHR_video_queue> enabled!" ); 12544 12545 VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities; 12546 VULKAN_HPP_NAMESPACE::Result result = 12547 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( 12548 static_cast<VkPhysicalDevice>( m_physicalDevice ), 12549 reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ), 12550 reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) ); 12551 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12552 { 12553 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); 12554 } 12555 return capabilities; 12556 } 12557 12558 template <typename X, typename Y, typename... Z> 12559 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile) const12560 PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR & videoProfile ) const 12561 { 12562 StructureChain<X, Y, Z...> structureChain; 12563 VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities = 12564 structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>(); 12565 VULKAN_HPP_NAMESPACE::Result result = 12566 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( 12567 static_cast<VkPhysicalDevice>( m_physicalDevice ), 12568 reinterpret_cast<const VkVideoProfileKHR *>( &videoProfile ), 12569 reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) ); 12570 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12571 { 12572 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); 12573 } 12574 return structureChain; 12575 } 12576 12577 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> getVideoFormatPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo) const12578 PhysicalDevice::getVideoFormatPropertiesKHR( 12579 const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const 12580 { 12581 VULKAN_HPP_ASSERT( 12582 getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR && 12583 "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> needs extension <VK_KHR_video_queue> enabled!" ); 12584 12585 std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> videoFormatProperties; 12586 uint32_t videoFormatPropertyCount; 12587 VULKAN_HPP_NAMESPACE::Result result; 12588 do 12589 { 12590 result = 12591 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( 12592 static_cast<VkPhysicalDevice>( m_physicalDevice ), 12593 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), 12594 &videoFormatPropertyCount, 12595 nullptr ) ); 12596 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoFormatPropertyCount ) 12597 { 12598 videoFormatProperties.resize( videoFormatPropertyCount ); 12599 result = 12600 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( 12601 static_cast<VkPhysicalDevice>( m_physicalDevice ), 12602 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), 12603 &videoFormatPropertyCount, 12604 reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) ); 12605 } 12606 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12607 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12608 { 12609 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); 12610 } 12611 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12612 { 12613 VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); 12614 if ( videoFormatPropertyCount < videoFormatProperties.size() ) 12615 { 12616 videoFormatProperties.resize( videoFormatPropertyCount ); 12617 } 12618 } 12619 return videoFormatProperties; 12620 } 12621 createVideoSessionKHR(VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12622 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR Device::createVideoSessionKHR( 12623 VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, 12624 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12625 { 12626 return VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR( *this, createInfo, allocator ); 12627 } 12628 12629 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> getMemoryRequirements() const12630 VideoSessionKHR::getMemoryRequirements() const 12631 { 12632 VULKAN_HPP_ASSERT( 12633 getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR && 12634 "Function <vkGetVideoSessionMemoryRequirementsKHR> needs extension <VK_KHR_video_queue> enabled!" ); 12635 12636 std::vector<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR> videoSessionMemoryRequirements; 12637 uint32_t videoSessionMemoryRequirementsCount; 12638 VULKAN_HPP_NAMESPACE::Result result; 12639 do 12640 { 12641 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12642 getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( m_device ), 12643 static_cast<VkVideoSessionKHR>( m_videoSession ), 12644 &videoSessionMemoryRequirementsCount, 12645 nullptr ) ); 12646 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoSessionMemoryRequirementsCount ) 12647 { 12648 videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount ); 12649 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( 12650 static_cast<VkDevice>( m_device ), 12651 static_cast<VkVideoSessionKHR>( m_videoSession ), 12652 &videoSessionMemoryRequirementsCount, 12653 reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( videoSessionMemoryRequirements.data() ) ) ); 12654 } 12655 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12656 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12657 { 12658 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::getMemoryRequirements" ); 12659 } 12660 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12661 { 12662 VULKAN_HPP_ASSERT( videoSessionMemoryRequirementsCount <= videoSessionMemoryRequirements.size() ); 12663 if ( videoSessionMemoryRequirementsCount < videoSessionMemoryRequirements.size() ) 12664 { 12665 videoSessionMemoryRequirements.resize( videoSessionMemoryRequirementsCount ); 12666 } 12667 } 12668 return videoSessionMemoryRequirements; 12669 } 12670 bindMemory(ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories) const12671 VULKAN_HPP_INLINE void VideoSessionKHR::bindMemory( 12672 ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories ) const 12673 { 12674 VULKAN_HPP_ASSERT( getDispatcher()->vkBindVideoSessionMemoryKHR && 12675 "Function <vkBindVideoSessionMemoryKHR> needs extension <VK_KHR_video_queue> enabled!" ); 12676 12677 VULKAN_HPP_NAMESPACE::Result result = 12678 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindVideoSessionMemoryKHR( 12679 static_cast<VkDevice>( m_device ), 12680 static_cast<VkVideoSessionKHR>( m_videoSession ), 12681 videoSessionBindMemories.size(), 12682 reinterpret_cast<const VkVideoBindMemoryKHR *>( videoSessionBindMemories.data() ) ) ); 12683 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12684 { 12685 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::bindMemory" ); 12686 } 12687 } 12688 12689 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR createVideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12690 Device::createVideoSessionParametersKHR( 12691 VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo, 12692 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12693 { 12694 return VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR( *this, createInfo, allocator ); 12695 } 12696 update(const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo) const12697 VULKAN_HPP_INLINE void VideoSessionParametersKHR::update( 12698 const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const 12699 { 12700 VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateVideoSessionParametersKHR && 12701 "Function <vkUpdateVideoSessionParametersKHR> needs extension <VK_KHR_video_queue> enabled!" ); 12702 12703 VULKAN_HPP_NAMESPACE::Result result = 12704 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkUpdateVideoSessionParametersKHR( 12705 static_cast<VkDevice>( m_device ), 12706 static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ), 12707 reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) ); 12708 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12709 { 12710 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionParametersKHR::update" ); 12711 } 12712 } 12713 beginVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo) const12714 VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( 12715 const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT 12716 { 12717 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginVideoCodingKHR && 12718 "Function <vkCmdBeginVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" ); 12719 12720 getDispatcher()->vkCmdBeginVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 12721 reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) ); 12722 } 12723 endVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo) const12724 VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( 12725 const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT 12726 { 12727 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndVideoCodingKHR && 12728 "Function <vkCmdEndVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" ); 12729 12730 getDispatcher()->vkCmdEndVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 12731 reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) ); 12732 } 12733 controlVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo) const12734 VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( 12735 const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT 12736 { 12737 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdControlVideoCodingKHR && 12738 "Function <vkCmdControlVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" ); 12739 12740 getDispatcher()->vkCmdControlVideoCodingKHR( 12741 static_cast<VkCommandBuffer>( m_commandBuffer ), 12742 reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) ); 12743 } 12744 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 12745 12746 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 12747 //=== VK_KHR_video_decode_queue === 12748 decodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & frameInfo) const12749 VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( 12750 const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & frameInfo ) const VULKAN_HPP_NOEXCEPT 12751 { 12752 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecodeVideoKHR && 12753 "Function <vkCmdDecodeVideoKHR> needs extension <VK_KHR_video_decode_queue> enabled!" ); 12754 12755 getDispatcher()->vkCmdDecodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 12756 reinterpret_cast<const VkVideoDecodeInfoKHR *>( &frameInfo ) ); 12757 } 12758 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 12759 12760 //=== VK_EXT_transform_feedback === 12761 bindTransformFeedbackBuffersEXT(uint32_t firstBinding,ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes) const12762 VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( 12763 uint32_t firstBinding, 12764 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 12765 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 12766 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 12767 { 12768 VULKAN_HPP_ASSERT( 12769 getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT && 12770 "Function <vkCmdBindTransformFeedbackBuffersEXT> needs extension <VK_EXT_transform_feedback> enabled!" ); 12771 12772 # ifdef VULKAN_HPP_NO_EXCEPTIONS 12773 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); 12774 VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); 12775 # else 12776 if ( buffers.size() != offsets.size() ) 12777 { 12778 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 12779 "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); 12780 } 12781 if ( !sizes.empty() && buffers.size() != sizes.size() ) 12782 { 12783 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 12784 "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); 12785 } 12786 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 12787 12788 getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 12789 firstBinding, 12790 buffers.size(), 12791 reinterpret_cast<const VkBuffer *>( buffers.data() ), 12792 reinterpret_cast<const VkDeviceSize *>( offsets.data() ), 12793 reinterpret_cast<const VkDeviceSize *>( sizes.data() ) ); 12794 } 12795 beginTransformFeedbackEXT(uint32_t firstCounterBuffer,ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets) const12796 VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( 12797 uint32_t firstCounterBuffer, 12798 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, 12799 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const 12800 VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 12801 { 12802 VULKAN_HPP_ASSERT( 12803 getDispatcher()->vkCmdBeginTransformFeedbackEXT && 12804 "Function <vkCmdBeginTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" ); 12805 12806 # ifdef VULKAN_HPP_NO_EXCEPTIONS 12807 VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); 12808 # else 12809 if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) 12810 { 12811 throw LogicError( 12812 VULKAN_HPP_NAMESPACE_STRING 12813 "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); 12814 } 12815 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 12816 12817 getDispatcher()->vkCmdBeginTransformFeedbackEXT( 12818 static_cast<VkCommandBuffer>( m_commandBuffer ), 12819 firstCounterBuffer, 12820 counterBuffers.size(), 12821 reinterpret_cast<const VkBuffer *>( counterBuffers.data() ), 12822 reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) ); 12823 } 12824 endTransformFeedbackEXT(uint32_t firstCounterBuffer,ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets) const12825 VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( 12826 uint32_t firstCounterBuffer, 12827 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, 12828 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const 12829 VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 12830 { 12831 VULKAN_HPP_ASSERT( 12832 getDispatcher()->vkCmdEndTransformFeedbackEXT && 12833 "Function <vkCmdEndTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" ); 12834 12835 # ifdef VULKAN_HPP_NO_EXCEPTIONS 12836 VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); 12837 # else 12838 if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) 12839 { 12840 throw LogicError( 12841 VULKAN_HPP_NAMESPACE_STRING 12842 "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); 12843 } 12844 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 12845 12846 getDispatcher()->vkCmdEndTransformFeedbackEXT( 12847 static_cast<VkCommandBuffer>( m_commandBuffer ), 12848 firstCounterBuffer, 12849 counterBuffers.size(), 12850 reinterpret_cast<const VkBuffer *>( counterBuffers.data() ), 12851 reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) ); 12852 } 12853 beginQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query,VULKAN_HPP_NAMESPACE::QueryControlFlags flags,uint32_t index) const12854 VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 12855 uint32_t query, 12856 VULKAN_HPP_NAMESPACE::QueryControlFlags flags, 12857 uint32_t index ) const VULKAN_HPP_NOEXCEPT 12858 { 12859 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQueryIndexedEXT && 12860 "Function <vkCmdBeginQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" ); 12861 12862 getDispatcher()->vkCmdBeginQueryIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 12863 static_cast<VkQueryPool>( queryPool ), 12864 query, 12865 static_cast<VkQueryControlFlags>( flags ), 12866 index ); 12867 } 12868 endQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query,uint32_t index) const12869 VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 12870 uint32_t query, 12871 uint32_t index ) const VULKAN_HPP_NOEXCEPT 12872 { 12873 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQueryIndexedEXT && 12874 "Function <vkCmdEndQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" ); 12875 12876 getDispatcher()->vkCmdEndQueryIndexedEXT( 12877 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, index ); 12878 } 12879 12880 VULKAN_HPP_INLINE void drawIndirectByteCountEXT(uint32_t instanceCount,uint32_t firstInstance,VULKAN_HPP_NAMESPACE::Buffer counterBuffer,VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,uint32_t counterOffset,uint32_t vertexStride) const12881 CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, 12882 uint32_t firstInstance, 12883 VULKAN_HPP_NAMESPACE::Buffer counterBuffer, 12884 VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, 12885 uint32_t counterOffset, 12886 uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT 12887 { 12888 VULKAN_HPP_ASSERT( 12889 getDispatcher()->vkCmdDrawIndirectByteCountEXT && 12890 "Function <vkCmdDrawIndirectByteCountEXT> needs extension <VK_EXT_transform_feedback> enabled!" ); 12891 12892 getDispatcher()->vkCmdDrawIndirectByteCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 12893 instanceCount, 12894 firstInstance, 12895 static_cast<VkBuffer>( counterBuffer ), 12896 static_cast<VkDeviceSize>( counterBufferOffset ), 12897 counterOffset, 12898 vertexStride ); 12899 } 12900 12901 //=== VK_NVX_binary_import === 12902 createCuModuleNVX(VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12903 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX Device::createCuModuleNVX( 12904 VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo, 12905 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12906 { 12907 return VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX( *this, createInfo, allocator ); 12908 } 12909 createCuFunctionNVX(VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12910 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX Device::createCuFunctionNVX( 12911 VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo, 12912 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12913 { 12914 return VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX( *this, createInfo, allocator ); 12915 } 12916 cuLaunchKernelNVX(const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo) const12917 VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( 12918 const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT 12919 { 12920 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCuLaunchKernelNVX && 12921 "Function <vkCmdCuLaunchKernelNVX> needs extension <VK_NVX_binary_import> enabled!" ); 12922 12923 getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast<VkCommandBuffer>( m_commandBuffer ), 12924 reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) ); 12925 } 12926 12927 //=== VK_NVX_image_view_handle === 12928 getImageViewHandleNVX(const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info) const12929 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( 12930 const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT 12931 { 12932 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandleNVX && 12933 "Function <vkGetImageViewHandleNVX> needs extension <VK_NVX_image_view_handle> enabled!" ); 12934 12935 return getDispatcher()->vkGetImageViewHandleNVX( static_cast<VkDevice>( m_device ), 12936 reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) ); 12937 } 12938 12939 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const12940 ImageView::getAddressNVX() const 12941 { 12942 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX && 12943 "Function <vkGetImageViewAddressNVX> needs extension <VK_NVX_image_view_handle> enabled!" ); 12944 12945 VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties; 12946 VULKAN_HPP_NAMESPACE::Result result = 12947 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageViewAddressNVX( 12948 static_cast<VkDevice>( m_device ), 12949 static_cast<VkImageView>( m_imageView ), 12950 reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) ); 12951 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12952 { 12953 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::ImageView::getAddressNVX" ); 12954 } 12955 return properties; 12956 } 12957 12958 //=== VK_AMD_draw_indirect_count === 12959 drawIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::Buffer countBuffer,VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const12960 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, 12961 VULKAN_HPP_NAMESPACE::DeviceSize offset, 12962 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 12963 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 12964 uint32_t maxDrawCount, 12965 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 12966 { 12967 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountAMD && 12968 "Function <vkCmdDrawIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" ); 12969 12970 getDispatcher()->vkCmdDrawIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ), 12971 static_cast<VkBuffer>( buffer ), 12972 static_cast<VkDeviceSize>( offset ), 12973 static_cast<VkBuffer>( countBuffer ), 12974 static_cast<VkDeviceSize>( countBufferOffset ), 12975 maxDrawCount, 12976 stride ); 12977 } 12978 12979 VULKAN_HPP_INLINE void drawIndexedIndirectCountAMD(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::Buffer countBuffer,VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const12980 CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, 12981 VULKAN_HPP_NAMESPACE::DeviceSize offset, 12982 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 12983 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 12984 uint32_t maxDrawCount, 12985 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 12986 { 12987 VULKAN_HPP_ASSERT( 12988 getDispatcher()->vkCmdDrawIndexedIndirectCountAMD && 12989 "Function <vkCmdDrawIndexedIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" ); 12990 12991 getDispatcher()->vkCmdDrawIndexedIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ), 12992 static_cast<VkBuffer>( buffer ), 12993 static_cast<VkDeviceSize>( offset ), 12994 static_cast<VkBuffer>( countBuffer ), 12995 static_cast<VkDeviceSize>( countBufferOffset ), 12996 maxDrawCount, 12997 stride ); 12998 } 12999 13000 //=== VK_AMD_shader_info === 13001 13002 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> getShaderInfoAMD(VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType) const13003 Pipeline::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, 13004 VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType ) const 13005 { 13006 VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderInfoAMD && 13007 "Function <vkGetShaderInfoAMD> needs extension <VK_AMD_shader_info> enabled!" ); 13008 13009 std::vector<uint8_t> info; 13010 size_t infoSize; 13011 VULKAN_HPP_NAMESPACE::Result result; 13012 do 13013 { 13014 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 13015 getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ), 13016 static_cast<VkPipeline>( m_pipeline ), 13017 static_cast<VkShaderStageFlagBits>( shaderStage ), 13018 static_cast<VkShaderInfoTypeAMD>( infoType ), 13019 &infoSize, 13020 nullptr ) ); 13021 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && infoSize ) 13022 { 13023 info.resize( infoSize ); 13024 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 13025 getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ), 13026 static_cast<VkPipeline>( m_pipeline ), 13027 static_cast<VkShaderStageFlagBits>( shaderStage ), 13028 static_cast<VkShaderInfoTypeAMD>( infoType ), 13029 &infoSize, 13030 reinterpret_cast<void *>( info.data() ) ) ); 13031 } 13032 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 13033 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13034 { 13035 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getShaderInfoAMD" ); 13036 } 13037 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13038 { 13039 VULKAN_HPP_ASSERT( infoSize <= info.size() ); 13040 if ( infoSize < info.size() ) 13041 { 13042 info.resize( infoSize ); 13043 } 13044 } 13045 return info; 13046 } 13047 13048 //=== VK_KHR_dynamic_rendering === 13049 beginRenderingKHR(const VULKAN_HPP_NAMESPACE::RenderingInfoKHR & renderingInfo) const13050 VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( 13051 const VULKAN_HPP_NAMESPACE::RenderingInfoKHR & renderingInfo ) const VULKAN_HPP_NOEXCEPT 13052 { 13053 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderingKHR && 13054 "Function <vkCmdBeginRenderingKHR> needs extension <VK_KHR_dynamic_rendering> enabled!" ); 13055 13056 getDispatcher()->vkCmdBeginRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 13057 reinterpret_cast<const VkRenderingInfoKHR *>( &renderingInfo ) ); 13058 } 13059 endRenderingKHR() const13060 VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR() const VULKAN_HPP_NOEXCEPT 13061 { 13062 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderingKHR && 13063 "Function <vkCmdEndRenderingKHR> needs extension <VK_KHR_dynamic_rendering> enabled!" ); 13064 13065 getDispatcher()->vkCmdEndRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 13066 } 13067 13068 # if defined( VK_USE_PLATFORM_GGP ) 13069 //=== VK_GGP_stream_descriptor_surface === 13070 13071 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createStreamDescriptorSurfaceGGP(VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13072 Instance::createStreamDescriptorSurfaceGGP( 13073 VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, 13074 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13075 { 13076 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 13077 } 13078 # endif /*VK_USE_PLATFORM_GGP*/ 13079 13080 //=== VK_NV_external_memory_capabilities === 13081 13082 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV getExternalImageFormatPropertiesNV(VULKAN_HPP_NAMESPACE::Format format,VULKAN_HPP_NAMESPACE::ImageType type,VULKAN_HPP_NAMESPACE::ImageTiling tiling,VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,VULKAN_HPP_NAMESPACE::ImageCreateFlags flags,VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType) const13083 PhysicalDevice::getExternalImageFormatPropertiesNV( 13084 VULKAN_HPP_NAMESPACE::Format format, 13085 VULKAN_HPP_NAMESPACE::ImageType type, 13086 VULKAN_HPP_NAMESPACE::ImageTiling tiling, 13087 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 13088 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, 13089 VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType ) const 13090 { 13091 VULKAN_HPP_ASSERT( 13092 getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV && 13093 "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> needs extension <VK_NV_external_memory_capabilities> enabled!" ); 13094 13095 VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties; 13096 VULKAN_HPP_NAMESPACE::Result result = 13097 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 13098 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13099 static_cast<VkFormat>( format ), 13100 static_cast<VkImageType>( type ), 13101 static_cast<VkImageTiling>( tiling ), 13102 static_cast<VkImageUsageFlags>( usage ), 13103 static_cast<VkImageCreateFlags>( flags ), 13104 static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), 13105 reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) ); 13106 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13107 { 13108 throwResultException( result, 13109 VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); 13110 } 13111 return externalImageFormatProperties; 13112 } 13113 13114 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 13115 //=== VK_NV_external_memory_win32 === 13116 13117 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE getMemoryWin32HandleNV(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType) const13118 DeviceMemory::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const 13119 { 13120 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleNV && 13121 "Function <vkGetMemoryWin32HandleNV> needs extension <VK_NV_external_memory_win32> enabled!" ); 13122 13123 HANDLE handle; 13124 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 13125 getDispatcher()->vkGetMemoryWin32HandleNV( static_cast<VkDevice>( m_device ), 13126 static_cast<VkDeviceMemory>( m_memory ), 13127 static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), 13128 &handle ) ); 13129 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13130 { 13131 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" ); 13132 } 13133 return handle; 13134 } 13135 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13136 13137 //=== VK_KHR_get_physical_device_properties2 === 13138 13139 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR() const13140 PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT 13141 { 13142 VULKAN_HPP_ASSERT( 13143 getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && 13144 "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13145 13146 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; 13147 getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 13148 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); 13149 return features; 13150 } 13151 13152 template <typename X, typename Y, typename... Z> 13153 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> getFeatures2KHR() const13154 PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT 13155 { 13156 VULKAN_HPP_ASSERT( 13157 getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && 13158 "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13159 13160 StructureChain<X, Y, Z...> structureChain; 13161 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = 13162 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); 13163 getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 13164 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); 13165 return structureChain; 13166 } 13167 13168 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2KHR() const13169 PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT 13170 { 13171 VULKAN_HPP_ASSERT( 13172 getDispatcher()->vkGetPhysicalDeviceProperties2KHR && 13173 "Function <vkGetPhysicalDeviceProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13174 13175 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; 13176 getDispatcher()->vkGetPhysicalDeviceProperties2KHR( 13177 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13178 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); 13179 return properties; 13180 } 13181 13182 template <typename X, typename Y, typename... Z> 13183 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> getProperties2KHR() const13184 PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT 13185 { 13186 VULKAN_HPP_ASSERT( 13187 getDispatcher()->vkGetPhysicalDeviceProperties2KHR && 13188 "Function <vkGetPhysicalDeviceProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13189 13190 StructureChain<X, Y, Z...> structureChain; 13191 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = 13192 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); 13193 getDispatcher()->vkGetPhysicalDeviceProperties2KHR( 13194 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13195 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); 13196 return structureChain; 13197 } 13198 13199 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format) const13200 PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 13201 { 13202 VULKAN_HPP_ASSERT( 13203 getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && 13204 "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13205 13206 VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; 13207 getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( 13208 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13209 static_cast<VkFormat>( format ), 13210 reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); 13211 return formatProperties; 13212 } 13213 13214 template <typename X, typename Y, typename... Z> 13215 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format) const13216 PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 13217 { 13218 VULKAN_HPP_ASSERT( 13219 getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && 13220 "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13221 13222 StructureChain<X, Y, Z...> structureChain; 13223 VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = 13224 structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); 13225 getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( 13226 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13227 static_cast<VkFormat>( format ), 13228 reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); 13229 return structureChain; 13230 } 13231 13232 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2 getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo) const13233 PhysicalDevice::getImageFormatProperties2KHR( 13234 const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const 13235 { 13236 VULKAN_HPP_ASSERT( 13237 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && 13238 "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13239 13240 VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; 13241 VULKAN_HPP_NAMESPACE::Result result = 13242 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( 13243 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13244 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), 13245 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); 13246 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13247 { 13248 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); 13249 } 13250 return imageFormatProperties; 13251 } 13252 13253 template <typename X, typename Y, typename... Z> getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo) const13254 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> PhysicalDevice::getImageFormatProperties2KHR( 13255 const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const 13256 { 13257 StructureChain<X, Y, Z...> structureChain; 13258 VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = 13259 structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); 13260 VULKAN_HPP_NAMESPACE::Result result = 13261 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( 13262 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13263 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), 13264 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); 13265 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13266 { 13267 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); 13268 } 13269 return structureChain; 13270 } 13271 13272 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2KHR() const13273 PhysicalDevice::getQueueFamilyProperties2KHR() const VULKAN_HPP_NOEXCEPT 13274 { 13275 VULKAN_HPP_ASSERT( 13276 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && 13277 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13278 13279 uint32_t queueFamilyPropertyCount; 13280 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( 13281 static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 13282 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); 13283 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( 13284 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13285 &queueFamilyPropertyCount, 13286 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); 13287 VULKAN_HPP_ASSERT( queueFamilyPropertyCount == queueFamilyProperties.size() ); 13288 return queueFamilyProperties; 13289 } 13290 13291 template <typename StructureChain> 13292 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> getQueueFamilyProperties2KHR() const13293 PhysicalDevice::getQueueFamilyProperties2KHR() const 13294 { 13295 VULKAN_HPP_ASSERT( 13296 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && 13297 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13298 13299 uint32_t queueFamilyPropertyCount; 13300 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( 13301 static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 13302 std::vector<StructureChain> returnVector( queueFamilyPropertyCount ); 13303 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties( queueFamilyPropertyCount ); 13304 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) 13305 { 13306 queueFamilyProperties[i].pNext = 13307 returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; 13308 } 13309 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( 13310 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13311 &queueFamilyPropertyCount, 13312 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); 13313 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); 13314 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) 13315 { 13316 returnVector[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; 13317 } 13318 return returnVector; 13319 } 13320 13321 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR() const13322 PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT 13323 { 13324 VULKAN_HPP_ASSERT( 13325 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && 13326 "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13327 13328 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; 13329 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( 13330 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13331 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); 13332 return memoryProperties; 13333 } 13334 13335 template <typename X, typename Y, typename... Z> 13336 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> getMemoryProperties2KHR() const13337 PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT 13338 { 13339 VULKAN_HPP_ASSERT( 13340 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && 13341 "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13342 13343 StructureChain<X, Y, Z...> structureChain; 13344 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = 13345 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); 13346 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( 13347 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13348 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); 13349 return structureChain; 13350 } 13351 13352 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> getSparseImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo) const13353 PhysicalDevice::getSparseImageFormatProperties2KHR( 13354 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const VULKAN_HPP_NOEXCEPT 13355 { 13356 VULKAN_HPP_ASSERT( 13357 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR && 13358 "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" ); 13359 13360 uint32_t propertyCount; 13361 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( 13362 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13363 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), 13364 &propertyCount, 13365 nullptr ); 13366 std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties( propertyCount ); 13367 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( 13368 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13369 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), 13370 &propertyCount, 13371 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); 13372 VULKAN_HPP_ASSERT( propertyCount == properties.size() ); 13373 return properties; 13374 } 13375 13376 //=== VK_KHR_device_group === 13377 13378 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex) const13379 Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, 13380 uint32_t localDeviceIndex, 13381 uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT 13382 { 13383 VULKAN_HPP_ASSERT( 13384 getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR && 13385 "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> needs extension <VK_KHR_device_group> enabled!" ); 13386 13387 VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; 13388 getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR( 13389 static_cast<VkDevice>( m_device ), 13390 heapIndex, 13391 localDeviceIndex, 13392 remoteDeviceIndex, 13393 reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) ); 13394 return peerMemoryFeatures; 13395 } 13396 setDeviceMaskKHR(uint32_t deviceMask) const13397 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT 13398 { 13399 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMaskKHR && 13400 "Function <vkCmdSetDeviceMaskKHR> needs extension <VK_KHR_device_group> enabled!" ); 13401 13402 getDispatcher()->vkCmdSetDeviceMaskKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask ); 13403 } 13404 dispatchBaseKHR(uint32_t baseGroupX,uint32_t baseGroupY,uint32_t baseGroupZ,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const13405 VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, 13406 uint32_t baseGroupY, 13407 uint32_t baseGroupZ, 13408 uint32_t groupCountX, 13409 uint32_t groupCountY, 13410 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 13411 { 13412 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBaseKHR && 13413 "Function <vkCmdDispatchBaseKHR> needs extension <VK_KHR_device_group> enabled!" ); 13414 13415 getDispatcher()->vkCmdDispatchBaseKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 13416 baseGroupX, 13417 baseGroupY, 13418 baseGroupZ, 13419 groupCountX, 13420 groupCountY, 13421 groupCountZ ); 13422 } 13423 13424 # if defined( VK_USE_PLATFORM_VI_NN ) 13425 //=== VK_NN_vi_surface === 13426 createViSurfaceNN(VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13427 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createViSurfaceNN( 13428 VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, 13429 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13430 { 13431 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 13432 } 13433 # endif /*VK_USE_PLATFORM_VI_NN*/ 13434 13435 //=== VK_KHR_maintenance1 === 13436 13437 VULKAN_HPP_INLINE void trimKHR(VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags) const13438 CommandPool::trimKHR( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT 13439 { 13440 VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR && 13441 "Function <vkTrimCommandPoolKHR> needs extension <VK_KHR_maintenance1> enabled!" ); 13442 13443 getDispatcher()->vkTrimCommandPoolKHR( static_cast<VkDevice>( m_device ), 13444 static_cast<VkCommandPool>( m_commandPool ), 13445 static_cast<VkCommandPoolTrimFlags>( flags ) ); 13446 } 13447 13448 //=== VK_KHR_device_group_creation === 13449 13450 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroupsKHR() const13451 Instance::enumeratePhysicalDeviceGroupsKHR() const 13452 { 13453 VULKAN_HPP_ASSERT( 13454 getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR && 13455 "Function <vkEnumeratePhysicalDeviceGroupsKHR> needs extension <VK_KHR_device_group_creation> enabled!" ); 13456 13457 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties; 13458 uint32_t physicalDeviceGroupCount; 13459 VULKAN_HPP_NAMESPACE::Result result; 13460 do 13461 { 13462 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( 13463 static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) ); 13464 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount ) 13465 { 13466 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); 13467 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( 13468 static_cast<VkInstance>( m_instance ), 13469 &physicalDeviceGroupCount, 13470 reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); 13471 } 13472 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 13473 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13474 { 13475 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); 13476 } 13477 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13478 { 13479 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); 13480 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) 13481 { 13482 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); 13483 } 13484 } 13485 return physicalDeviceGroupProperties; 13486 } 13487 13488 //=== VK_KHR_external_memory_capabilities === 13489 13490 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo) const13491 PhysicalDevice::getExternalBufferPropertiesKHR( 13492 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT 13493 { 13494 VULKAN_HPP_ASSERT( 13495 getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR && 13496 "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> needs extension <VK_KHR_external_memory_capabilities> enabled!" ); 13497 13498 VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; 13499 getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR( 13500 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13501 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ), 13502 reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) ); 13503 return externalBufferProperties; 13504 } 13505 13506 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 13507 //=== VK_KHR_external_memory_win32 === 13508 getMemoryWin32HandleKHR(const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo) const13509 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE Device::getMemoryWin32HandleKHR( 13510 const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const 13511 { 13512 VULKAN_HPP_ASSERT( 13513 getDispatcher()->vkGetMemoryWin32HandleKHR && 13514 "Function <vkGetMemoryWin32HandleKHR> needs extension <VK_KHR_external_memory_win32> enabled!" ); 13515 13516 HANDLE handle; 13517 VULKAN_HPP_NAMESPACE::Result result = 13518 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandleKHR( 13519 static_cast<VkDevice>( m_device ), 13520 reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), 13521 &handle ) ); 13522 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13523 { 13524 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); 13525 } 13526 return handle; 13527 } 13528 13529 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR getMemoryWin32HandlePropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,HANDLE handle) const13530 Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, 13531 HANDLE handle ) const 13532 { 13533 VULKAN_HPP_ASSERT( 13534 getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR && 13535 "Function <vkGetMemoryWin32HandlePropertiesKHR> needs extension <VK_KHR_external_memory_win32> enabled!" ); 13536 13537 VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; 13538 VULKAN_HPP_NAMESPACE::Result result = 13539 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR( 13540 static_cast<VkDevice>( m_device ), 13541 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), 13542 handle, 13543 reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) ); 13544 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13545 { 13546 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); 13547 } 13548 return memoryWin32HandleProperties; 13549 } 13550 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13551 13552 //=== VK_KHR_external_memory_fd === 13553 13554 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int getMemoryFdKHR(const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo) const13555 Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo ) const 13556 { 13557 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdKHR && 13558 "Function <vkGetMemoryFdKHR> needs extension <VK_KHR_external_memory_fd> enabled!" ); 13559 13560 int fd; 13561 VULKAN_HPP_NAMESPACE::Result result = 13562 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryFdKHR( 13563 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) ); 13564 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13565 { 13566 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); 13567 } 13568 return fd; 13569 } 13570 13571 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR getMemoryFdPropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,int fd) const13572 Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, 13573 int fd ) const 13574 { 13575 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdPropertiesKHR && 13576 "Function <vkGetMemoryFdPropertiesKHR> needs extension <VK_KHR_external_memory_fd> enabled!" ); 13577 13578 VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties; 13579 VULKAN_HPP_NAMESPACE::Result result = 13580 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryFdPropertiesKHR( 13581 static_cast<VkDevice>( m_device ), 13582 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), 13583 fd, 13584 reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) ); 13585 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13586 { 13587 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); 13588 } 13589 return memoryFdProperties; 13590 } 13591 13592 //=== VK_KHR_external_semaphore_capabilities === 13593 13594 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo) const13595 PhysicalDevice::getExternalSemaphorePropertiesKHR( 13596 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const 13597 VULKAN_HPP_NOEXCEPT 13598 { 13599 VULKAN_HPP_ASSERT( 13600 getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR && 13601 "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> needs extension <VK_KHR_external_semaphore_capabilities> enabled!" ); 13602 13603 VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; 13604 getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 13605 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13606 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ), 13607 reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) ); 13608 return externalSemaphoreProperties; 13609 } 13610 13611 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 13612 //=== VK_KHR_external_semaphore_win32 === 13613 importSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo) const13614 VULKAN_HPP_INLINE void Device::importSemaphoreWin32HandleKHR( 13615 const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const 13616 { 13617 VULKAN_HPP_ASSERT( 13618 getDispatcher()->vkImportSemaphoreWin32HandleKHR && 13619 "Function <vkImportSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" ); 13620 13621 VULKAN_HPP_NAMESPACE::Result result = 13622 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreWin32HandleKHR( 13623 static_cast<VkDevice>( m_device ), 13624 reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) ); 13625 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13626 { 13627 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); 13628 } 13629 } 13630 getSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo) const13631 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE Device::getSemaphoreWin32HandleKHR( 13632 const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const 13633 { 13634 VULKAN_HPP_ASSERT( 13635 getDispatcher()->vkGetSemaphoreWin32HandleKHR && 13636 "Function <vkGetSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" ); 13637 13638 HANDLE handle; 13639 VULKAN_HPP_NAMESPACE::Result result = 13640 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreWin32HandleKHR( 13641 static_cast<VkDevice>( m_device ), 13642 reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), 13643 &handle ) ); 13644 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13645 { 13646 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); 13647 } 13648 return handle; 13649 } 13650 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13651 13652 //=== VK_KHR_external_semaphore_fd === 13653 13654 VULKAN_HPP_INLINE void importSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo) const13655 Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const 13656 { 13657 VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreFdKHR && 13658 "Function <vkImportSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!" ); 13659 13660 VULKAN_HPP_NAMESPACE::Result result = 13661 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreFdKHR( 13662 static_cast<VkDevice>( m_device ), 13663 reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) ); 13664 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13665 { 13666 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); 13667 } 13668 } 13669 13670 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int getSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo) const13671 Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo ) const 13672 { 13673 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreFdKHR && 13674 "Function <vkGetSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!" ); 13675 13676 int fd; 13677 VULKAN_HPP_NAMESPACE::Result result = 13678 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreFdKHR( 13679 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) ); 13680 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13681 { 13682 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); 13683 } 13684 return fd; 13685 } 13686 13687 //=== VK_KHR_push_descriptor === 13688 pushDescriptorSetKHR(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t set,ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites) const13689 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( 13690 VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 13691 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 13692 uint32_t set, 13693 ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT 13694 { 13695 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetKHR && 13696 "Function <vkCmdPushDescriptorSetKHR> needs extension <VK_KHR_push_descriptor> enabled!" ); 13697 13698 getDispatcher()->vkCmdPushDescriptorSetKHR( 13699 static_cast<VkCommandBuffer>( m_commandBuffer ), 13700 static_cast<VkPipelineBindPoint>( pipelineBindPoint ), 13701 static_cast<VkPipelineLayout>( layout ), 13702 set, 13703 descriptorWrites.size(), 13704 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) ); 13705 } 13706 pushDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t set,const void * pData) const13707 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( 13708 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 13709 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 13710 uint32_t set, 13711 const void * pData ) const VULKAN_HPP_NOEXCEPT 13712 { 13713 VULKAN_HPP_ASSERT( 13714 getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR && 13715 "Function <vkCmdPushDescriptorSetWithTemplateKHR> needs extension <VK_KHR_push_descriptor> enabled!" ); 13716 13717 getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR( 13718 static_cast<VkCommandBuffer>( m_commandBuffer ), 13719 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), 13720 static_cast<VkPipelineLayout>( layout ), 13721 set, 13722 pData ); 13723 } 13724 13725 //=== VK_EXT_conditional_rendering === 13726 beginConditionalRenderingEXT(const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin) const13727 VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( 13728 const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const 13729 VULKAN_HPP_NOEXCEPT 13730 { 13731 VULKAN_HPP_ASSERT( 13732 getDispatcher()->vkCmdBeginConditionalRenderingEXT && 13733 "Function <vkCmdBeginConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" ); 13734 13735 getDispatcher()->vkCmdBeginConditionalRenderingEXT( 13736 static_cast<VkCommandBuffer>( m_commandBuffer ), 13737 reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) ); 13738 } 13739 endConditionalRenderingEXT() const13740 VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT 13741 { 13742 VULKAN_HPP_ASSERT( 13743 getDispatcher()->vkCmdEndConditionalRenderingEXT && 13744 "Function <vkCmdEndConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" ); 13745 13746 getDispatcher()->vkCmdEndConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 13747 } 13748 13749 //=== VK_KHR_descriptor_update_template === 13750 13751 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate createDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13752 Device::createDescriptorUpdateTemplateKHR( 13753 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 13754 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13755 { 13756 return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( *this, createInfo, allocator ); 13757 } 13758 destroyDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13759 VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( 13760 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 13761 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT 13762 { 13763 VULKAN_HPP_ASSERT( 13764 getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR && 13765 "Function <vkDestroyDescriptorUpdateTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" ); 13766 13767 getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR( 13768 static_cast<VkDevice>( m_device ), 13769 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), 13770 reinterpret_cast<const VkAllocationCallbacks *>( 13771 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); 13772 } 13773 13774 VULKAN_HPP_INLINE void updateWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,const void * pData) const13775 DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 13776 const void * pData ) const VULKAN_HPP_NOEXCEPT 13777 { 13778 VULKAN_HPP_ASSERT( 13779 getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR && 13780 "Function <vkUpdateDescriptorSetWithTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" ); 13781 13782 getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR( 13783 static_cast<VkDevice>( m_device ), 13784 static_cast<VkDescriptorSet>( m_descriptorSet ), 13785 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), 13786 pData ); 13787 } 13788 13789 //=== VK_NV_clip_space_w_scaling === 13790 setViewportWScalingNV(uint32_t firstViewport,ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings) const13791 VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( 13792 uint32_t firstViewport, 13793 ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT 13794 { 13795 VULKAN_HPP_ASSERT( 13796 getDispatcher()->vkCmdSetViewportWScalingNV && 13797 "Function <vkCmdSetViewportWScalingNV> needs extension <VK_NV_clip_space_w_scaling> enabled!" ); 13798 13799 getDispatcher()->vkCmdSetViewportWScalingNV( 13800 static_cast<VkCommandBuffer>( m_commandBuffer ), 13801 firstViewport, 13802 viewportWScalings.size(), 13803 reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) ); 13804 } 13805 13806 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 13807 //=== VK_EXT_acquire_xlib_display === 13808 acquireXlibDisplayEXT(Display & dpy,VULKAN_HPP_NAMESPACE::DisplayKHR display) const13809 VULKAN_HPP_INLINE void PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, 13810 VULKAN_HPP_NAMESPACE::DisplayKHR display ) const 13811 { 13812 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireXlibDisplayEXT && 13813 "Function <vkAcquireXlibDisplayEXT> needs extension <VK_EXT_acquire_xlib_display> enabled!" ); 13814 13815 VULKAN_HPP_NAMESPACE::Result result = 13816 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireXlibDisplayEXT( 13817 static_cast<VkPhysicalDevice>( m_physicalDevice ), &dpy, static_cast<VkDisplayKHR>( display ) ) ); 13818 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13819 { 13820 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); 13821 } 13822 } 13823 13824 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getRandROutputDisplayEXT(Display & dpy,RROutput rrOutput) const13825 PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const 13826 { 13827 return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, dpy, rrOutput ); 13828 } 13829 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 13830 13831 //=== VK_EXT_display_surface_counter === 13832 13833 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT getSurfaceCapabilities2EXT(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const13834 PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 13835 { 13836 VULKAN_HPP_ASSERT( 13837 getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT && 13838 "Function <vkGetPhysicalDeviceSurfaceCapabilities2EXT> needs extension <VK_EXT_display_surface_counter> enabled!" ); 13839 13840 VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities; 13841 VULKAN_HPP_NAMESPACE::Result result = 13842 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT( 13843 static_cast<VkPhysicalDevice>( m_physicalDevice ), 13844 static_cast<VkSurfaceKHR>( surface ), 13845 reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) ) ); 13846 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13847 { 13848 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); 13849 } 13850 return surfaceCapabilities; 13851 } 13852 13853 //=== VK_EXT_display_control === 13854 13855 VULKAN_HPP_INLINE void displayPowerControlEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display,const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo) const13856 Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, 13857 const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo ) const 13858 { 13859 VULKAN_HPP_ASSERT( getDispatcher()->vkDisplayPowerControlEXT && 13860 "Function <vkDisplayPowerControlEXT> needs extension <VK_EXT_display_control> enabled!" ); 13861 13862 VULKAN_HPP_NAMESPACE::Result result = 13863 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDisplayPowerControlEXT( 13864 static_cast<VkDevice>( m_device ), 13865 static_cast<VkDisplayKHR>( display ), 13866 reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) ); 13867 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13868 { 13869 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); 13870 } 13871 } 13872 registerEventEXT(VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13873 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Fence Device::registerEventEXT( 13874 VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo, 13875 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13876 { 13877 return VULKAN_HPP_RAII_NAMESPACE::Fence( *this, deviceEventInfo, allocator ); 13878 } 13879 registerDisplayEventEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13880 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Fence Device::registerDisplayEventEXT( 13881 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, 13882 VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo, 13883 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13884 { 13885 return VULKAN_HPP_RAII_NAMESPACE::Fence( *this, display, displayEventInfo, allocator ); 13886 } 13887 13888 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t getCounterEXT(VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter) const13889 SwapchainKHR::getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const 13890 { 13891 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainCounterEXT && 13892 "Function <vkGetSwapchainCounterEXT> needs extension <VK_EXT_display_control> enabled!" ); 13893 13894 uint64_t counterValue; 13895 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 13896 getDispatcher()->vkGetSwapchainCounterEXT( static_cast<VkDevice>( m_device ), 13897 static_cast<VkSwapchainKHR>( m_swapchain ), 13898 static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), 13899 &counterValue ) ); 13900 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13901 { 13902 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" ); 13903 } 13904 return counterValue; 13905 } 13906 13907 //=== VK_GOOGLE_display_timing === 13908 13909 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE getRefreshCycleDurationGOOGLE() const13910 SwapchainKHR::getRefreshCycleDurationGOOGLE() const 13911 { 13912 VULKAN_HPP_ASSERT( 13913 getDispatcher()->vkGetRefreshCycleDurationGOOGLE && 13914 "Function <vkGetRefreshCycleDurationGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" ); 13915 13916 VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties; 13917 VULKAN_HPP_NAMESPACE::Result result = 13918 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRefreshCycleDurationGOOGLE( 13919 static_cast<VkDevice>( m_device ), 13920 static_cast<VkSwapchainKHR>( m_swapchain ), 13921 reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) ); 13922 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13923 { 13924 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" ); 13925 } 13926 return displayTimingProperties; 13927 } 13928 13929 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> getPastPresentationTimingGOOGLE() const13930 SwapchainKHR::getPastPresentationTimingGOOGLE() const 13931 { 13932 VULKAN_HPP_ASSERT( 13933 getDispatcher()->vkGetPastPresentationTimingGOOGLE && 13934 "Function <vkGetPastPresentationTimingGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" ); 13935 13936 std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> presentationTimings; 13937 uint32_t presentationTimingCount; 13938 VULKAN_HPP_NAMESPACE::Result result; 13939 do 13940 { 13941 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 13942 getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast<VkDevice>( m_device ), 13943 static_cast<VkSwapchainKHR>( m_swapchain ), 13944 &presentationTimingCount, 13945 nullptr ) ); 13946 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount ) 13947 { 13948 presentationTimings.resize( presentationTimingCount ); 13949 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPastPresentationTimingGOOGLE( 13950 static_cast<VkDevice>( m_device ), 13951 static_cast<VkSwapchainKHR>( m_swapchain ), 13952 &presentationTimingCount, 13953 reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) ); 13954 } 13955 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 13956 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13957 { 13958 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE" ); 13959 } 13960 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13961 { 13962 VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); 13963 if ( presentationTimingCount < presentationTimings.size() ) 13964 { 13965 presentationTimings.resize( presentationTimingCount ); 13966 } 13967 } 13968 return presentationTimings; 13969 } 13970 13971 //=== VK_EXT_discard_rectangles === 13972 setDiscardRectangleEXT(uint32_t firstDiscardRectangle,ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles) const13973 VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( 13974 uint32_t firstDiscardRectangle, 13975 ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT 13976 { 13977 VULKAN_HPP_ASSERT( 13978 getDispatcher()->vkCmdSetDiscardRectangleEXT && 13979 "Function <vkCmdSetDiscardRectangleEXT> needs extension <VK_EXT_discard_rectangles> enabled!" ); 13980 13981 getDispatcher()->vkCmdSetDiscardRectangleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 13982 firstDiscardRectangle, 13983 discardRectangles.size(), 13984 reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) ); 13985 } 13986 13987 //=== VK_EXT_hdr_metadata === 13988 13989 VULKAN_HPP_INLINE void setHdrMetadataEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata) const13990 Device::setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, 13991 ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const 13992 VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 13993 { 13994 VULKAN_HPP_ASSERT( getDispatcher()->vkSetHdrMetadataEXT && 13995 "Function <vkSetHdrMetadataEXT> needs extension <VK_EXT_hdr_metadata> enabled!" ); 13996 13997 # ifdef VULKAN_HPP_NO_EXCEPTIONS 13998 VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); 13999 # else 14000 if ( swapchains.size() != metadata.size() ) 14001 { 14002 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 14003 "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); 14004 } 14005 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 14006 14007 getDispatcher()->vkSetHdrMetadataEXT( static_cast<VkDevice>( m_device ), 14008 swapchains.size(), 14009 reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ), 14010 reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) ); 14011 } 14012 14013 //=== VK_KHR_create_renderpass2 === 14014 createRenderPass2KHR(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const14015 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::RenderPass Device::createRenderPass2KHR( 14016 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 14017 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 14018 { 14019 return VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, createInfo, allocator ); 14020 } 14021 beginRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo) const14022 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( 14023 const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 14024 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 14025 { 14026 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2KHR && 14027 "Function <vkCmdBeginRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" ); 14028 14029 getDispatcher()->vkCmdBeginRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 14030 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), 14031 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) ); 14032 } 14033 nextSubpass2KHR(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo) const14034 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( 14035 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, 14036 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 14037 { 14038 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2KHR && 14039 "Function <vkCmdNextSubpass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" ); 14040 14041 getDispatcher()->vkCmdNextSubpass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 14042 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), 14043 reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); 14044 } 14045 endRenderPass2KHR(const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo) const14046 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( 14047 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 14048 { 14049 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2KHR && 14050 "Function <vkCmdEndRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" ); 14051 14052 getDispatcher()->vkCmdEndRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 14053 reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); 14054 } 14055 14056 //=== VK_KHR_shared_presentable_image === 14057 getStatus() const14058 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result SwapchainKHR::getStatus() const 14059 { 14060 VULKAN_HPP_ASSERT( 14061 getDispatcher()->vkGetSwapchainStatusKHR && 14062 "Function <vkGetSwapchainStatusKHR> needs extension <VK_KHR_shared_presentable_image> enabled!" ); 14063 14064 VULKAN_HPP_NAMESPACE::Result result = 14065 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainStatusKHR( 14066 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) ); 14067 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 14068 ( result != VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR ) ) 14069 { 14070 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus" ); 14071 } 14072 return result; 14073 } 14074 14075 //=== VK_KHR_external_fence_capabilities === 14076 14077 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo) const14078 PhysicalDevice::getExternalFencePropertiesKHR( 14079 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT 14080 { 14081 VULKAN_HPP_ASSERT( 14082 getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR && 14083 "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> needs extension <VK_KHR_external_fence_capabilities> enabled!" ); 14084 14085 VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; 14086 getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR( 14087 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14088 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ), 14089 reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) ); 14090 return externalFenceProperties; 14091 } 14092 14093 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 14094 //=== VK_KHR_external_fence_win32 === 14095 importFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo) const14096 VULKAN_HPP_INLINE void Device::importFenceWin32HandleKHR( 14097 const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const 14098 { 14099 VULKAN_HPP_ASSERT( 14100 getDispatcher()->vkImportFenceWin32HandleKHR && 14101 "Function <vkImportFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" ); 14102 14103 VULKAN_HPP_NAMESPACE::Result result = 14104 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportFenceWin32HandleKHR( 14105 static_cast<VkDevice>( m_device ), 14106 reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) ); 14107 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14108 { 14109 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); 14110 } 14111 } 14112 getFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo) const14113 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE Device::getFenceWin32HandleKHR( 14114 const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const 14115 { 14116 VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceWin32HandleKHR && 14117 "Function <vkGetFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" ); 14118 14119 HANDLE handle; 14120 VULKAN_HPP_NAMESPACE::Result result = 14121 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceWin32HandleKHR( 14122 static_cast<VkDevice>( m_device ), 14123 reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), 14124 &handle ) ); 14125 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14126 { 14127 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); 14128 } 14129 return handle; 14130 } 14131 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14132 14133 //=== VK_KHR_external_fence_fd === 14134 14135 VULKAN_HPP_INLINE void importFenceFdKHR(const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo) const14136 Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo ) const 14137 { 14138 VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceFdKHR && 14139 "Function <vkImportFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!" ); 14140 14141 VULKAN_HPP_NAMESPACE::Result result = 14142 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportFenceFdKHR( 14143 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) ); 14144 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14145 { 14146 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" ); 14147 } 14148 } 14149 14150 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int getFenceFdKHR(const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo) const14151 Device::getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo ) const 14152 { 14153 VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceFdKHR && 14154 "Function <vkGetFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!" ); 14155 14156 int fd; 14157 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceFdKHR( 14158 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) ); 14159 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14160 { 14161 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); 14162 } 14163 return fd; 14164 } 14165 14166 //=== VK_KHR_performance_query === 14167 14168 VULKAN_HPP_NODISCARD 14169 VULKAN_HPP_INLINE std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>> enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex) const14170 PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const 14171 { 14172 VULKAN_HPP_ASSERT( 14173 getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && 14174 "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> needs extension <VK_KHR_performance_query> enabled!" ); 14175 14176 std::pair<std::vector<PerformanceCounterKHR>, std::vector<PerformanceCounterDescriptionKHR>> data; 14177 std::vector<PerformanceCounterKHR> & counters = data.first; 14178 std::vector<PerformanceCounterDescriptionKHR> & counterDescriptions = data.second; 14179 uint32_t counterCount; 14180 VULKAN_HPP_NAMESPACE::Result result; 14181 do 14182 { 14183 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14184 getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 14185 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr ) ); 14186 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && counterCount ) 14187 { 14188 counters.resize( counterCount ); 14189 counterDescriptions.resize( counterCount ); 14190 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14191 getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 14192 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14193 queueFamilyIndex, 14194 &counterCount, 14195 reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), 14196 reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) ); 14197 VULKAN_HPP_ASSERT( counterCount <= counters.size() ); 14198 } 14199 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 14200 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( counterCount < counters.size() ) ) 14201 { 14202 counters.resize( counterCount ); 14203 counterDescriptions.resize( counterCount ); 14204 } 14205 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14206 { 14207 throwResultException( 14208 result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); 14209 } 14210 return data; 14211 } 14212 getQueueFamilyPerformanceQueryPassesKHR(const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo) const14213 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( 14214 const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const 14215 VULKAN_HPP_NOEXCEPT 14216 { 14217 VULKAN_HPP_ASSERT( 14218 getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR && 14219 "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> needs extension <VK_KHR_performance_query> enabled!" ); 14220 14221 uint32_t numPasses; 14222 getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( 14223 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14224 reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ), 14225 &numPasses ); 14226 return numPasses; 14227 } 14228 14229 VULKAN_HPP_INLINE void acquireProfilingLockKHR(const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info) const14230 Device::acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info ) const 14231 { 14232 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireProfilingLockKHR && 14233 "Function <vkAcquireProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" ); 14234 14235 VULKAN_HPP_NAMESPACE::Result result = 14236 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireProfilingLockKHR( 14237 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) ); 14238 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14239 { 14240 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); 14241 } 14242 } 14243 releaseProfilingLockKHR() const14244 VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT 14245 { 14246 VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseProfilingLockKHR && 14247 "Function <vkReleaseProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" ); 14248 14249 getDispatcher()->vkReleaseProfilingLockKHR( static_cast<VkDevice>( m_device ) ); 14250 } 14251 14252 //=== VK_KHR_get_surface_capabilities2 === 14253 14254 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const14255 PhysicalDevice::getSurfaceCapabilities2KHR( 14256 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 14257 { 14258 VULKAN_HPP_ASSERT( 14259 getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && 14260 "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" ); 14261 14262 VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities; 14263 VULKAN_HPP_NAMESPACE::Result result = 14264 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( 14265 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14266 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 14267 reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) ); 14268 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14269 { 14270 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); 14271 } 14272 return surfaceCapabilities; 14273 } 14274 14275 template <typename X, typename Y, typename... Z> getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const14276 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> PhysicalDevice::getSurfaceCapabilities2KHR( 14277 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 14278 { 14279 StructureChain<X, Y, Z...> structureChain; 14280 VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR & surfaceCapabilities = 14281 structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>(); 14282 VULKAN_HPP_NAMESPACE::Result result = 14283 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( 14284 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14285 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 14286 reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) ); 14287 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14288 { 14289 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); 14290 } 14291 return structureChain; 14292 } 14293 14294 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> getSurfaceFormats2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const14295 PhysicalDevice::getSurfaceFormats2KHR( 14296 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 14297 { 14298 VULKAN_HPP_ASSERT( 14299 getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR && 14300 "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" ); 14301 14302 std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats; 14303 uint32_t surfaceFormatCount; 14304 VULKAN_HPP_NAMESPACE::Result result; 14305 do 14306 { 14307 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( 14308 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14309 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 14310 &surfaceFormatCount, 14311 nullptr ) ); 14312 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) 14313 { 14314 surfaceFormats.resize( surfaceFormatCount ); 14315 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( 14316 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14317 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 14318 &surfaceFormatCount, 14319 reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) ); 14320 } 14321 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 14322 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14323 { 14324 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); 14325 } 14326 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14327 { 14328 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); 14329 if ( surfaceFormatCount < surfaceFormats.size() ) 14330 { 14331 surfaceFormats.resize( surfaceFormatCount ); 14332 } 14333 } 14334 return surfaceFormats; 14335 } 14336 14337 //=== VK_KHR_get_display_properties2 === 14338 14339 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> getDisplayProperties2KHR() const14340 PhysicalDevice::getDisplayProperties2KHR() const 14341 { 14342 VULKAN_HPP_ASSERT( 14343 getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR && 14344 "Function <vkGetPhysicalDeviceDisplayProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" ); 14345 14346 std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> properties; 14347 uint32_t propertyCount; 14348 VULKAN_HPP_NAMESPACE::Result result; 14349 do 14350 { 14351 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( 14352 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 14353 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 14354 { 14355 properties.resize( propertyCount ); 14356 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( 14357 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14358 &propertyCount, 14359 reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) ); 14360 } 14361 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 14362 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14363 { 14364 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); 14365 } 14366 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14367 { 14368 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 14369 if ( propertyCount < properties.size() ) 14370 { 14371 properties.resize( propertyCount ); 14372 } 14373 } 14374 return properties; 14375 } 14376 14377 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> getDisplayPlaneProperties2KHR() const14378 PhysicalDevice::getDisplayPlaneProperties2KHR() const 14379 { 14380 VULKAN_HPP_ASSERT( 14381 getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR && 14382 "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" ); 14383 14384 std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> properties; 14385 uint32_t propertyCount; 14386 VULKAN_HPP_NAMESPACE::Result result; 14387 do 14388 { 14389 result = 14390 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( 14391 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 14392 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 14393 { 14394 properties.resize( propertyCount ); 14395 result = 14396 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( 14397 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14398 &propertyCount, 14399 reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) ); 14400 } 14401 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 14402 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14403 { 14404 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); 14405 } 14406 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14407 { 14408 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 14409 if ( propertyCount < properties.size() ) 14410 { 14411 properties.resize( propertyCount ); 14412 } 14413 } 14414 return properties; 14415 } 14416 14417 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const14418 DisplayKHR::getModeProperties2() const 14419 { 14420 VULKAN_HPP_ASSERT( 14421 getDispatcher()->vkGetDisplayModeProperties2KHR && 14422 "Function <vkGetDisplayModeProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" ); 14423 14424 std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> properties; 14425 uint32_t propertyCount; 14426 VULKAN_HPP_NAMESPACE::Result result; 14427 do 14428 { 14429 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14430 getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14431 static_cast<VkDisplayKHR>( m_display ), 14432 &propertyCount, 14433 nullptr ) ); 14434 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 14435 { 14436 properties.resize( propertyCount ); 14437 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModeProperties2KHR( 14438 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14439 static_cast<VkDisplayKHR>( m_display ), 14440 &propertyCount, 14441 reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) ); 14442 } 14443 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 14444 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14445 { 14446 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" ); 14447 } 14448 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14449 { 14450 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 14451 if ( propertyCount < properties.size() ) 14452 { 14453 properties.resize( propertyCount ); 14454 } 14455 } 14456 return properties; 14457 } 14458 14459 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR getDisplayPlaneCapabilities2KHR(const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo) const14460 PhysicalDevice::getDisplayPlaneCapabilities2KHR( 14461 const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const 14462 { 14463 VULKAN_HPP_ASSERT( 14464 getDispatcher()->vkGetDisplayPlaneCapabilities2KHR && 14465 "Function <vkGetDisplayPlaneCapabilities2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" ); 14466 14467 VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities; 14468 VULKAN_HPP_NAMESPACE::Result result = 14469 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayPlaneCapabilities2KHR( 14470 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14471 reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ), 14472 reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) ); 14473 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14474 { 14475 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); 14476 } 14477 return capabilities; 14478 } 14479 14480 # if defined( VK_USE_PLATFORM_IOS_MVK ) 14481 //=== VK_MVK_ios_surface === 14482 createIOSSurfaceMVK(VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const14483 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createIOSSurfaceMVK( 14484 VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo, 14485 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 14486 { 14487 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 14488 } 14489 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 14490 14491 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 14492 //=== VK_MVK_macos_surface === 14493 createMacOSSurfaceMVK(VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const14494 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createMacOSSurfaceMVK( 14495 VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo, 14496 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 14497 { 14498 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 14499 } 14500 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 14501 14502 //=== VK_EXT_debug_utils === 14503 14504 VULKAN_HPP_INLINE void setDebugUtilsObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo) const14505 Device::setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo ) const 14506 { 14507 VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectNameEXT && 14508 "Function <vkSetDebugUtilsObjectNameEXT> needs extension <VK_EXT_debug_utils> enabled!" ); 14509 14510 VULKAN_HPP_NAMESPACE::Result result = 14511 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetDebugUtilsObjectNameEXT( 14512 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) ); 14513 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14514 { 14515 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); 14516 } 14517 } 14518 14519 VULKAN_HPP_INLINE void setDebugUtilsObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo) const14520 Device::setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo ) const 14521 { 14522 VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectTagEXT && 14523 "Function <vkSetDebugUtilsObjectTagEXT> needs extension <VK_EXT_debug_utils> enabled!" ); 14524 14525 VULKAN_HPP_NAMESPACE::Result result = 14526 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetDebugUtilsObjectTagEXT( 14527 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) ); 14528 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14529 { 14530 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); 14531 } 14532 } 14533 beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo) const14534 VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( 14535 const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT 14536 { 14537 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBeginDebugUtilsLabelEXT && 14538 "Function <vkQueueBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" ); 14539 14540 getDispatcher()->vkQueueBeginDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), 14541 reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); 14542 } 14543 endDebugUtilsLabelEXT() const14544 VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT 14545 { 14546 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueEndDebugUtilsLabelEXT && 14547 "Function <vkQueueEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" ); 14548 14549 getDispatcher()->vkQueueEndDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ) ); 14550 } 14551 insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo) const14552 VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( 14553 const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT 14554 { 14555 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueInsertDebugUtilsLabelEXT && 14556 "Function <vkQueueInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" ); 14557 14558 getDispatcher()->vkQueueInsertDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), 14559 reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); 14560 } 14561 beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo) const14562 VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( 14563 const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT 14564 { 14565 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginDebugUtilsLabelEXT && 14566 "Function <vkCmdBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" ); 14567 14568 getDispatcher()->vkCmdBeginDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 14569 reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); 14570 } 14571 endDebugUtilsLabelEXT() const14572 VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT 14573 { 14574 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndDebugUtilsLabelEXT && 14575 "Function <vkCmdEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" ); 14576 14577 getDispatcher()->vkCmdEndDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 14578 } 14579 insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo) const14580 VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( 14581 const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT 14582 { 14583 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInsertDebugUtilsLabelEXT && 14584 "Function <vkCmdInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" ); 14585 14586 getDispatcher()->vkCmdInsertDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 14587 reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); 14588 } 14589 14590 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT createDebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const14591 Instance::createDebugUtilsMessengerEXT( 14592 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo, 14593 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 14594 { 14595 return VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT( *this, createInfo, allocator ); 14596 } 14597 submitDebugUtilsMessageEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes,const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData) const14598 VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( 14599 VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 14600 VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, 14601 const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT 14602 { 14603 VULKAN_HPP_ASSERT( getDispatcher()->vkSubmitDebugUtilsMessageEXT && 14604 "Function <vkSubmitDebugUtilsMessageEXT> needs extension <VK_EXT_debug_utils> enabled!" ); 14605 14606 getDispatcher()->vkSubmitDebugUtilsMessageEXT( 14607 static_cast<VkInstance>( m_instance ), 14608 static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), 14609 static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), 14610 reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) ); 14611 } 14612 14613 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 14614 //=== VK_ANDROID_external_memory_android_hardware_buffer === 14615 14616 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer & buffer) const14617 Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const 14618 { 14619 VULKAN_HPP_ASSERT( 14620 getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && 14621 "Function <vkGetAndroidHardwareBufferPropertiesANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" ); 14622 14623 VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties; 14624 VULKAN_HPP_NAMESPACE::Result result = 14625 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( 14626 static_cast<VkDevice>( m_device ), 14627 &buffer, 14628 reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) ); 14629 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14630 { 14631 throwResultException( result, 14632 VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); 14633 } 14634 return properties; 14635 } 14636 14637 template <typename X, typename Y, typename... Z> 14638 VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer & buffer) const14639 Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const 14640 { 14641 StructureChain<X, Y, Z...> structureChain; 14642 VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties = 14643 structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>(); 14644 VULKAN_HPP_NAMESPACE::Result result = 14645 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( 14646 static_cast<VkDevice>( m_device ), 14647 &buffer, 14648 reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) ); 14649 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14650 { 14651 throwResultException( result, 14652 VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); 14653 } 14654 return structureChain; 14655 } 14656 getMemoryAndroidHardwareBufferANDROID(const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info) const14657 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE struct AHardwareBuffer * Device::getMemoryAndroidHardwareBufferANDROID( 14658 const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info ) const 14659 { 14660 VULKAN_HPP_ASSERT( 14661 getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID && 14662 "Function <vkGetMemoryAndroidHardwareBufferANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" ); 14663 14664 struct AHardwareBuffer * buffer; 14665 VULKAN_HPP_NAMESPACE::Result result = 14666 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID( 14667 static_cast<VkDevice>( m_device ), 14668 reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), 14669 &buffer ) ); 14670 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14671 { 14672 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); 14673 } 14674 return buffer; 14675 } 14676 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 14677 14678 //=== VK_EXT_sample_locations === 14679 setSampleLocationsEXT(const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo) const14680 VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( 14681 const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT 14682 { 14683 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEXT && 14684 "Function <vkCmdSetSampleLocationsEXT> needs extension <VK_EXT_sample_locations> enabled!" ); 14685 14686 getDispatcher()->vkCmdSetSampleLocationsEXT( 14687 static_cast<VkCommandBuffer>( m_commandBuffer ), 14688 reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) ); 14689 } 14690 14691 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples) const14692 PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const 14693 VULKAN_HPP_NOEXCEPT 14694 { 14695 VULKAN_HPP_ASSERT( 14696 getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT && 14697 "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> needs extension <VK_EXT_sample_locations> enabled!" ); 14698 14699 VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties; 14700 getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT( 14701 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14702 static_cast<VkSampleCountFlagBits>( samples ), 14703 reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) ); 14704 return multisampleProperties; 14705 } 14706 14707 //=== VK_KHR_get_memory_requirements2 === 14708 14709 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info) const14710 Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const 14711 VULKAN_HPP_NOEXCEPT 14712 { 14713 VULKAN_HPP_ASSERT( 14714 getDispatcher()->vkGetImageMemoryRequirements2KHR && 14715 "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" ); 14716 14717 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 14718 getDispatcher()->vkGetImageMemoryRequirements2KHR( 14719 static_cast<VkDevice>( m_device ), 14720 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), 14721 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 14722 return memoryRequirements; 14723 } 14724 14725 template <typename X, typename Y, typename... Z> getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info) const14726 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirements2KHR( 14727 const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 14728 { 14729 VULKAN_HPP_ASSERT( 14730 getDispatcher()->vkGetImageMemoryRequirements2KHR && 14731 "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" ); 14732 14733 StructureChain<X, Y, Z...> structureChain; 14734 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = 14735 structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 14736 getDispatcher()->vkGetImageMemoryRequirements2KHR( 14737 static_cast<VkDevice>( m_device ), 14738 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), 14739 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 14740 return structureChain; 14741 } 14742 14743 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info) const14744 Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const 14745 VULKAN_HPP_NOEXCEPT 14746 { 14747 VULKAN_HPP_ASSERT( 14748 getDispatcher()->vkGetBufferMemoryRequirements2KHR && 14749 "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" ); 14750 14751 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 14752 getDispatcher()->vkGetBufferMemoryRequirements2KHR( 14753 static_cast<VkDevice>( m_device ), 14754 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), 14755 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 14756 return memoryRequirements; 14757 } 14758 14759 template <typename X, typename Y, typename... Z> getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info) const14760 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirements2KHR( 14761 const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 14762 { 14763 VULKAN_HPP_ASSERT( 14764 getDispatcher()->vkGetBufferMemoryRequirements2KHR && 14765 "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" ); 14766 14767 StructureChain<X, Y, Z...> structureChain; 14768 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = 14769 structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 14770 getDispatcher()->vkGetBufferMemoryRequirements2KHR( 14771 static_cast<VkDevice>( m_device ), 14772 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), 14773 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 14774 return structureChain; 14775 } 14776 14777 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> getImageSparseMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info) const14778 Device::getImageSparseMemoryRequirements2KHR( 14779 const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 14780 { 14781 VULKAN_HPP_ASSERT( 14782 getDispatcher()->vkGetImageSparseMemoryRequirements2KHR && 14783 "Function <vkGetImageSparseMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" ); 14784 14785 uint32_t sparseMemoryRequirementCount; 14786 getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( 14787 static_cast<VkDevice>( m_device ), 14788 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), 14789 &sparseMemoryRequirementCount, 14790 nullptr ); 14791 std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements( 14792 sparseMemoryRequirementCount ); 14793 getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( 14794 static_cast<VkDevice>( m_device ), 14795 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), 14796 &sparseMemoryRequirementCount, 14797 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); 14798 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount == sparseMemoryRequirements.size() ); 14799 return sparseMemoryRequirements; 14800 } 14801 14802 //=== VK_KHR_acceleration_structure === 14803 14804 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR createAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const14805 Device::createAccelerationStructureKHR( 14806 VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo, 14807 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 14808 { 14809 return VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR( *this, createInfo, allocator ); 14810 } 14811 buildAccelerationStructuresKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos) const14812 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( 14813 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 14814 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) 14815 const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 14816 { 14817 VULKAN_HPP_ASSERT( 14818 getDispatcher()->vkCmdBuildAccelerationStructuresKHR && 14819 "Function <vkCmdBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 14820 14821 # ifdef VULKAN_HPP_NO_EXCEPTIONS 14822 VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); 14823 # else 14824 if ( infos.size() != pBuildRangeInfos.size() ) 14825 { 14826 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 14827 "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); 14828 } 14829 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 14830 14831 getDispatcher()->vkCmdBuildAccelerationStructuresKHR( 14832 static_cast<VkCommandBuffer>( m_commandBuffer ), 14833 infos.size(), 14834 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), 14835 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ); 14836 } 14837 buildAccelerationStructuresIndirectKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses,ArrayProxy<const uint32_t> const & indirectStrides,ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts) const14838 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( 14839 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 14840 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses, 14841 ArrayProxy<const uint32_t> const & indirectStrides, 14842 ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 14843 { 14844 VULKAN_HPP_ASSERT( 14845 getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR && 14846 "Function <vkCmdBuildAccelerationStructuresIndirectKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 14847 14848 # ifdef VULKAN_HPP_NO_EXCEPTIONS 14849 VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() ); 14850 VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() ); 14851 VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() ); 14852 # else 14853 if ( infos.size() != indirectDeviceAddresses.size() ) 14854 { 14855 throw LogicError( 14856 VULKAN_HPP_NAMESPACE_STRING 14857 "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" ); 14858 } 14859 if ( infos.size() != indirectStrides.size() ) 14860 { 14861 throw LogicError( 14862 VULKAN_HPP_NAMESPACE_STRING 14863 "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" ); 14864 } 14865 if ( infos.size() != pMaxPrimitiveCounts.size() ) 14866 { 14867 throw LogicError( 14868 VULKAN_HPP_NAMESPACE_STRING 14869 "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" ); 14870 } 14871 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 14872 14873 getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR( 14874 static_cast<VkCommandBuffer>( m_commandBuffer ), 14875 infos.size(), 14876 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), 14877 reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ), 14878 indirectStrides.data(), 14879 pMaxPrimitiveCounts.data() ); 14880 } 14881 buildAccelerationStructuresKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos) const14882 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::buildAccelerationStructuresKHR( 14883 VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 14884 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 14885 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) 14886 const 14887 { 14888 VULKAN_HPP_ASSERT( 14889 getDispatcher()->vkBuildAccelerationStructuresKHR && 14890 "Function <vkBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 14891 if ( infos.size() != pBuildRangeInfos.size() ) 14892 { 14893 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 14894 "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); 14895 } 14896 14897 VULKAN_HPP_NAMESPACE::Result result = 14898 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBuildAccelerationStructuresKHR( 14899 static_cast<VkDevice>( m_device ), 14900 static_cast<VkDeferredOperationKHR>( deferredOperation ), 14901 infos.size(), 14902 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), 14903 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ) ); 14904 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 14905 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) && 14906 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) ) 14907 { 14908 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR" ); 14909 } 14910 return result; 14911 } 14912 14913 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info) const14914 Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 14915 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const 14916 { 14917 VULKAN_HPP_ASSERT( 14918 getDispatcher()->vkCopyAccelerationStructureKHR && 14919 "Function <vkCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 14920 14921 VULKAN_HPP_NAMESPACE::Result result = 14922 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyAccelerationStructureKHR( 14923 static_cast<VkDevice>( m_device ), 14924 static_cast<VkDeferredOperationKHR>( deferredOperation ), 14925 reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ) ); 14926 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 14927 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) && 14928 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) ) 14929 { 14930 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR" ); 14931 } 14932 return result; 14933 } 14934 copyAccelerationStructureToMemoryKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info) const14935 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::copyAccelerationStructureToMemoryKHR( 14936 VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 14937 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const 14938 { 14939 VULKAN_HPP_ASSERT( 14940 getDispatcher()->vkCopyAccelerationStructureToMemoryKHR && 14941 "Function <vkCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 14942 14943 VULKAN_HPP_NAMESPACE::Result result = 14944 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyAccelerationStructureToMemoryKHR( 14945 static_cast<VkDevice>( m_device ), 14946 static_cast<VkDeferredOperationKHR>( deferredOperation ), 14947 reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ) ); 14948 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 14949 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) && 14950 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) ) 14951 { 14952 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR" ); 14953 } 14954 return result; 14955 } 14956 copyMemoryToAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info) const14957 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::copyMemoryToAccelerationStructureKHR( 14958 VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 14959 const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const 14960 { 14961 VULKAN_HPP_ASSERT( 14962 getDispatcher()->vkCopyMemoryToAccelerationStructureKHR && 14963 "Function <vkCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 14964 14965 VULKAN_HPP_NAMESPACE::Result result = 14966 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyMemoryToAccelerationStructureKHR( 14967 static_cast<VkDevice>( m_device ), 14968 static_cast<VkDeferredOperationKHR>( deferredOperation ), 14969 reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ) ); 14970 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 14971 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) && 14972 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) ) 14973 { 14974 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR" ); 14975 } 14976 return result; 14977 } 14978 14979 template <typename T> writeAccelerationStructuresPropertiesKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,VULKAN_HPP_NAMESPACE::QueryType queryType,size_t dataSize,size_t stride) const14980 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> Device::writeAccelerationStructuresPropertiesKHR( 14981 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 14982 VULKAN_HPP_NAMESPACE::QueryType queryType, 14983 size_t dataSize, 14984 size_t stride ) const 14985 { 14986 VULKAN_HPP_ASSERT( 14987 getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR && 14988 "Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 14989 14990 VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); 14991 std::vector<T> data( dataSize / sizeof( T ) ); 14992 Result result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( 14993 static_cast<VkDevice>( m_device ), 14994 accelerationStructures.size(), 14995 reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), 14996 static_cast<VkQueryType>( queryType ), 14997 data.size() * sizeof( T ), 14998 reinterpret_cast<void *>( data.data() ), 14999 stride ) ); 15000 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15001 { 15002 throwResultException( result, 15003 VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); 15004 } 15005 return data; 15006 } 15007 15008 template <typename T> writeAccelerationStructuresPropertyKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,VULKAN_HPP_NAMESPACE::QueryType queryType,size_t stride) const15009 VULKAN_HPP_NODISCARD T Device::writeAccelerationStructuresPropertyKHR( 15010 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 15011 VULKAN_HPP_NAMESPACE::QueryType queryType, 15012 size_t stride ) const 15013 { 15014 T data; 15015 Result result = static_cast<Result>( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( 15016 static_cast<VkDevice>( m_device ), 15017 accelerationStructures.size(), 15018 reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), 15019 static_cast<VkQueryType>( queryType ), 15020 sizeof( T ), 15021 reinterpret_cast<void *>( &data ), 15022 stride ) ); 15023 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15024 { 15025 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); 15026 } 15027 return data; 15028 } 15029 copyAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info) const15030 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( 15031 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT 15032 { 15033 VULKAN_HPP_ASSERT( 15034 getDispatcher()->vkCmdCopyAccelerationStructureKHR && 15035 "Function <vkCmdCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 15036 15037 getDispatcher()->vkCmdCopyAccelerationStructureKHR( 15038 static_cast<VkCommandBuffer>( m_commandBuffer ), 15039 reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ); 15040 } 15041 copyAccelerationStructureToMemoryKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info) const15042 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( 15043 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT 15044 { 15045 VULKAN_HPP_ASSERT( 15046 getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR && 15047 "Function <vkCmdCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 15048 15049 getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR( 15050 static_cast<VkCommandBuffer>( m_commandBuffer ), 15051 reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ); 15052 } 15053 copyMemoryToAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info) const15054 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( 15055 const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT 15056 { 15057 VULKAN_HPP_ASSERT( 15058 getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR && 15059 "Function <vkCmdCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 15060 15061 getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR( 15062 static_cast<VkCommandBuffer>( m_commandBuffer ), 15063 reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ); 15064 } 15065 15066 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress getAccelerationStructureAddressKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info) const15067 Device::getAccelerationStructureAddressKHR( 15068 const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT 15069 { 15070 VULKAN_HPP_ASSERT( 15071 getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR && 15072 "Function <vkGetAccelerationStructureDeviceAddressKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 15073 15074 return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( 15075 getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR( 15076 static_cast<VkDevice>( m_device ), 15077 reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) ) ); 15078 } 15079 writeAccelerationStructuresPropertiesKHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,VULKAN_HPP_NAMESPACE::QueryType queryType,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t firstQuery) const15080 VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( 15081 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 15082 VULKAN_HPP_NAMESPACE::QueryType queryType, 15083 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 15084 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT 15085 { 15086 VULKAN_HPP_ASSERT( 15087 getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR && 15088 "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 15089 15090 getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR( 15091 static_cast<VkCommandBuffer>( m_commandBuffer ), 15092 accelerationStructures.size(), 15093 reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), 15094 static_cast<VkQueryType>( queryType ), 15095 static_cast<VkQueryPool>( queryPool ), 15096 firstQuery ); 15097 } 15098 15099 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo) const15100 Device::getAccelerationStructureCompatibilityKHR( 15101 const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT 15102 { 15103 VULKAN_HPP_ASSERT( 15104 getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR && 15105 "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 15106 15107 VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility; 15108 getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR( 15109 static_cast<VkDevice>( m_device ), 15110 reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ), 15111 reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) ); 15112 return compatibility; 15113 } 15114 15115 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo,ArrayProxy<const uint32_t> const & maxPrimitiveCounts) const15116 Device::getAccelerationStructureBuildSizesKHR( 15117 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, 15118 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo, 15119 ArrayProxy<const uint32_t> const & maxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT 15120 { 15121 VULKAN_HPP_ASSERT( 15122 getDispatcher()->vkGetAccelerationStructureBuildSizesKHR && 15123 "Function <vkGetAccelerationStructureBuildSizesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" ); 15124 15125 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR sizeInfo; 15126 getDispatcher()->vkGetAccelerationStructureBuildSizesKHR( 15127 static_cast<VkDevice>( m_device ), 15128 static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ), 15129 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ), 15130 maxPrimitiveCounts.data(), 15131 reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) ); 15132 return sizeInfo; 15133 } 15134 15135 //=== VK_KHR_sampler_ycbcr_conversion === 15136 15137 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion createSamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const15138 Device::createSamplerYcbcrConversionKHR( 15139 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 15140 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 15141 { 15142 return VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion( *this, createInfo, allocator ); 15143 } 15144 destroySamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const15145 VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( 15146 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, 15147 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT 15148 { 15149 VULKAN_HPP_ASSERT( 15150 getDispatcher()->vkDestroySamplerYcbcrConversionKHR && 15151 "Function <vkDestroySamplerYcbcrConversionKHR> needs extension <VK_KHR_sampler_ycbcr_conversion> enabled!" ); 15152 15153 getDispatcher()->vkDestroySamplerYcbcrConversionKHR( 15154 static_cast<VkDevice>( m_device ), 15155 static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), 15156 reinterpret_cast<const VkAllocationCallbacks *>( 15157 static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); 15158 } 15159 15160 //=== VK_KHR_bind_memory2 === 15161 bindBufferMemory2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos) const15162 VULKAN_HPP_INLINE void Device::bindBufferMemory2KHR( 15163 ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const 15164 { 15165 VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2KHR && 15166 "Function <vkBindBufferMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!" ); 15167 15168 VULKAN_HPP_NAMESPACE::Result result = 15169 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindBufferMemory2KHR( 15170 static_cast<VkDevice>( m_device ), 15171 bindInfos.size(), 15172 reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) ); 15173 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15174 { 15175 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); 15176 } 15177 } 15178 15179 VULKAN_HPP_INLINE void bindImageMemory2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos) const15180 Device::bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const 15181 { 15182 VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2KHR && 15183 "Function <vkBindImageMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!" ); 15184 15185 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15186 getDispatcher()->vkBindImageMemory2KHR( static_cast<VkDevice>( m_device ), 15187 bindInfos.size(), 15188 reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) ); 15189 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15190 { 15191 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); 15192 } 15193 } 15194 15195 //=== VK_EXT_image_drm_format_modifier === 15196 15197 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT getDrmFormatModifierPropertiesEXT() const15198 Image::getDrmFormatModifierPropertiesEXT() const 15199 { 15200 VULKAN_HPP_ASSERT( 15201 getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT && 15202 "Function <vkGetImageDrmFormatModifierPropertiesEXT> needs extension <VK_EXT_image_drm_format_modifier> enabled!" ); 15203 15204 VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties; 15205 VULKAN_HPP_NAMESPACE::Result result = 15206 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT( 15207 static_cast<VkDevice>( m_device ), 15208 static_cast<VkImage>( m_image ), 15209 reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) ); 15210 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15211 { 15212 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" ); 15213 } 15214 return properties; 15215 } 15216 15217 //=== VK_EXT_validation_cache === 15218 15219 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT createValidationCacheEXT(VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const15220 Device::createValidationCacheEXT( 15221 VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo, 15222 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 15223 { 15224 return VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT( *this, createInfo, allocator ); 15225 } 15226 15227 VULKAN_HPP_INLINE void merge(ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches) const15228 ValidationCacheEXT::merge( ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const 15229 { 15230 VULKAN_HPP_ASSERT( getDispatcher()->vkMergeValidationCachesEXT && 15231 "Function <vkMergeValidationCachesEXT> needs extension <VK_EXT_validation_cache> enabled!" ); 15232 15233 VULKAN_HPP_NAMESPACE::Result result = 15234 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkMergeValidationCachesEXT( 15235 static_cast<VkDevice>( m_device ), 15236 static_cast<VkValidationCacheEXT>( m_validationCache ), 15237 srcCaches.size(), 15238 reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) ); 15239 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15240 { 15241 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::merge" ); 15242 } 15243 } 15244 getData() const15245 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ValidationCacheEXT::getData() const 15246 { 15247 VULKAN_HPP_ASSERT( getDispatcher()->vkGetValidationCacheDataEXT && 15248 "Function <vkGetValidationCacheDataEXT> needs extension <VK_EXT_validation_cache> enabled!" ); 15249 15250 std::vector<uint8_t> data; 15251 size_t dataSize; 15252 VULKAN_HPP_NAMESPACE::Result result; 15253 do 15254 { 15255 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15256 getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( m_device ), 15257 static_cast<VkValidationCacheEXT>( m_validationCache ), 15258 &dataSize, 15259 nullptr ) ); 15260 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) 15261 { 15262 data.resize( dataSize ); 15263 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15264 getDispatcher()->vkGetValidationCacheDataEXT( static_cast<VkDevice>( m_device ), 15265 static_cast<VkValidationCacheEXT>( m_validationCache ), 15266 &dataSize, 15267 reinterpret_cast<void *>( data.data() ) ) ); 15268 } 15269 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15270 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15271 { 15272 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::getData" ); 15273 } 15274 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15275 { 15276 VULKAN_HPP_ASSERT( dataSize <= data.size() ); 15277 if ( dataSize < data.size() ) 15278 { 15279 data.resize( dataSize ); 15280 } 15281 } 15282 return data; 15283 } 15284 15285 //=== VK_NV_shading_rate_image === 15286 15287 VULKAN_HPP_INLINE void bindShadingRateImageNV(VULKAN_HPP_NAMESPACE::ImageView imageView,VULKAN_HPP_NAMESPACE::ImageLayout imageLayout) const15288 CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, 15289 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT 15290 { 15291 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadingRateImageNV && 15292 "Function <vkCmdBindShadingRateImageNV> needs extension <VK_NV_shading_rate_image> enabled!" ); 15293 15294 getDispatcher()->vkCmdBindShadingRateImageNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 15295 static_cast<VkImageView>( imageView ), 15296 static_cast<VkImageLayout>( imageLayout ) ); 15297 } 15298 setViewportShadingRatePaletteNV(uint32_t firstViewport,ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes) const15299 VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( 15300 uint32_t firstViewport, ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes ) 15301 const VULKAN_HPP_NOEXCEPT 15302 { 15303 VULKAN_HPP_ASSERT( 15304 getDispatcher()->vkCmdSetViewportShadingRatePaletteNV && 15305 "Function <vkCmdSetViewportShadingRatePaletteNV> needs extension <VK_NV_shading_rate_image> enabled!" ); 15306 15307 getDispatcher()->vkCmdSetViewportShadingRatePaletteNV( 15308 static_cast<VkCommandBuffer>( m_commandBuffer ), 15309 firstViewport, 15310 shadingRatePalettes.size(), 15311 reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) ); 15312 } 15313 setCoarseSampleOrderNV(VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders) const15314 VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( 15315 VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, 15316 ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders ) const 15317 VULKAN_HPP_NOEXCEPT 15318 { 15319 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoarseSampleOrderNV && 15320 "Function <vkCmdSetCoarseSampleOrderNV> needs extension <VK_NV_shading_rate_image> enabled!" ); 15321 15322 getDispatcher()->vkCmdSetCoarseSampleOrderNV( 15323 static_cast<VkCommandBuffer>( m_commandBuffer ), 15324 static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), 15325 customSampleOrders.size(), 15326 reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) ); 15327 } 15328 15329 //=== VK_NV_ray_tracing === 15330 15331 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV createAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const15332 Device::createAccelerationStructureNV( 15333 VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo, 15334 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 15335 { 15336 return VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV( *this, createInfo, allocator ); 15337 } 15338 15339 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info) const15340 Device::getAccelerationStructureMemoryRequirementsNV( 15341 const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT 15342 { 15343 VULKAN_HPP_ASSERT( 15344 getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && 15345 "Function <vkGetAccelerationStructureMemoryRequirementsNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15346 15347 VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR memoryRequirements; 15348 getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( 15349 static_cast<VkDevice>( m_device ), 15350 reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ), 15351 reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) ); 15352 return memoryRequirements; 15353 } 15354 15355 template <typename X, typename Y, typename... Z> 15356 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info) const15357 Device::getAccelerationStructureMemoryRequirementsNV( 15358 const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT 15359 { 15360 VULKAN_HPP_ASSERT( 15361 getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && 15362 "Function <vkGetAccelerationStructureMemoryRequirementsNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15363 15364 StructureChain<X, Y, Z...> structureChain; 15365 VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR & memoryRequirements = 15366 structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>(); 15367 getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( 15368 static_cast<VkDevice>( m_device ), 15369 reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ), 15370 reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) ); 15371 return structureChain; 15372 } 15373 bindAccelerationStructureMemoryNV(ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos) const15374 VULKAN_HPP_INLINE void Device::bindAccelerationStructureMemoryNV( 15375 ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const 15376 { 15377 VULKAN_HPP_ASSERT( 15378 getDispatcher()->vkBindAccelerationStructureMemoryNV && 15379 "Function <vkBindAccelerationStructureMemoryNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15380 15381 VULKAN_HPP_NAMESPACE::Result result = 15382 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindAccelerationStructureMemoryNV( 15383 static_cast<VkDevice>( m_device ), 15384 bindInfos.size(), 15385 reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) ); 15386 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15387 { 15388 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); 15389 } 15390 } 15391 buildAccelerationStructureNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,VULKAN_HPP_NAMESPACE::Buffer instanceData,VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,VULKAN_HPP_NAMESPACE::Bool32 update,VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,VULKAN_HPP_NAMESPACE::Buffer scratch,VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset) const15392 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( 15393 const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info, 15394 VULKAN_HPP_NAMESPACE::Buffer instanceData, 15395 VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, 15396 VULKAN_HPP_NAMESPACE::Bool32 update, 15397 VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, 15398 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, 15399 VULKAN_HPP_NAMESPACE::Buffer scratch, 15400 VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT 15401 { 15402 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructureNV && 15403 "Function <vkCmdBuildAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15404 15405 getDispatcher()->vkCmdBuildAccelerationStructureNV( 15406 static_cast<VkCommandBuffer>( m_commandBuffer ), 15407 reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ), 15408 static_cast<VkBuffer>( instanceData ), 15409 static_cast<VkDeviceSize>( instanceOffset ), 15410 static_cast<VkBool32>( update ), 15411 static_cast<VkAccelerationStructureNV>( dst ), 15412 static_cast<VkAccelerationStructureNV>( src ), 15413 static_cast<VkBuffer>( scratch ), 15414 static_cast<VkDeviceSize>( scratchOffset ) ); 15415 } 15416 copyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode) const15417 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( 15418 VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, 15419 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, 15420 VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT 15421 { 15422 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureNV && 15423 "Function <vkCmdCopyAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15424 15425 getDispatcher()->vkCmdCopyAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 15426 static_cast<VkAccelerationStructureNV>( dst ), 15427 static_cast<VkAccelerationStructureNV>( src ), 15428 static_cast<VkCopyAccelerationStructureModeKHR>( mode ) ); 15429 } 15430 traceRaysNV(VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer,VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer,VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer,VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,uint32_t width,uint32_t height,uint32_t depth) const15431 VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, 15432 VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, 15433 VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, 15434 VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, 15435 VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, 15436 VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, 15437 VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, 15438 VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, 15439 VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, 15440 VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, 15441 VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, 15442 uint32_t width, 15443 uint32_t height, 15444 uint32_t depth ) const VULKAN_HPP_NOEXCEPT 15445 { 15446 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysNV && 15447 "Function <vkCmdTraceRaysNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15448 15449 getDispatcher()->vkCmdTraceRaysNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 15450 static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), 15451 static_cast<VkDeviceSize>( raygenShaderBindingOffset ), 15452 static_cast<VkBuffer>( missShaderBindingTableBuffer ), 15453 static_cast<VkDeviceSize>( missShaderBindingOffset ), 15454 static_cast<VkDeviceSize>( missShaderBindingStride ), 15455 static_cast<VkBuffer>( hitShaderBindingTableBuffer ), 15456 static_cast<VkDeviceSize>( hitShaderBindingOffset ), 15457 static_cast<VkDeviceSize>( hitShaderBindingStride ), 15458 static_cast<VkBuffer>( callableShaderBindingTableBuffer ), 15459 static_cast<VkDeviceSize>( callableShaderBindingOffset ), 15460 static_cast<VkDeviceSize>( callableShaderBindingStride ), 15461 width, 15462 height, 15463 depth ); 15464 } 15465 15466 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createRayTracingPipelinesNV(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const15467 Device::createRayTracingPipelinesNV( 15468 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 15469 pipelineCache, 15470 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, 15471 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 15472 { 15473 return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, pipelineCache, createInfos, allocator ); 15474 } 15475 createRayTracingPipelineNV(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const15476 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createRayTracingPipelineNV( 15477 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 15478 pipelineCache, 15479 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo, 15480 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 15481 { 15482 return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator ); 15483 } 15484 15485 template <typename T> 15486 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> getRayTracingShaderGroupHandlesNV(uint32_t firstGroup,uint32_t groupCount,size_t dataSize) const15487 Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const 15488 { 15489 VULKAN_HPP_ASSERT( 15490 getDispatcher()->vkGetRayTracingShaderGroupHandlesNV && 15491 "Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15492 15493 VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); 15494 std::vector<T> data( dataSize / sizeof( T ) ); 15495 Result result = static_cast<Result>( 15496 getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ), 15497 static_cast<VkPipeline>( m_pipeline ), 15498 firstGroup, 15499 groupCount, 15500 data.size() * sizeof( T ), 15501 reinterpret_cast<void *>( data.data() ) ) ); 15502 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15503 { 15504 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesNV" ); 15505 } 15506 return data; 15507 } 15508 15509 template <typename T> getRayTracingShaderGroupHandleNV(uint32_t firstGroup,uint32_t groupCount) const15510 VULKAN_HPP_NODISCARD T Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const 15511 { 15512 T data; 15513 Result result = static_cast<Result>( 15514 getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ), 15515 static_cast<VkPipeline>( m_pipeline ), 15516 firstGroup, 15517 groupCount, 15518 sizeof( T ), 15519 reinterpret_cast<void *>( &data ) ) ); 15520 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15521 { 15522 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleNV" ); 15523 } 15524 return data; 15525 } 15526 15527 template <typename T> getHandle(size_t dataSize) const15528 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> AccelerationStructureNV::getHandle( size_t dataSize ) const 15529 { 15530 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && 15531 "Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15532 15533 VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); 15534 std::vector<T> data( dataSize / sizeof( T ) ); 15535 Result result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV( 15536 static_cast<VkDevice>( m_device ), 15537 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ), 15538 data.size() * sizeof( T ), 15539 reinterpret_cast<void *>( data.data() ) ) ); 15540 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15541 { 15542 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); 15543 } 15544 return data; 15545 } 15546 15547 template <typename T> getHandle() const15548 VULKAN_HPP_NODISCARD T AccelerationStructureNV::getHandle() const 15549 { 15550 T data; 15551 Result result = static_cast<Result>( getDispatcher()->vkGetAccelerationStructureHandleNV( 15552 static_cast<VkDevice>( m_device ), 15553 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ), 15554 sizeof( T ), 15555 reinterpret_cast<void *>( &data ) ) ); 15556 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15557 { 15558 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); 15559 } 15560 return data; 15561 } 15562 writeAccelerationStructuresPropertiesNV(ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,VULKAN_HPP_NAMESPACE::QueryType queryType,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t firstQuery) const15563 VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( 15564 ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures, 15565 VULKAN_HPP_NAMESPACE::QueryType queryType, 15566 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 15567 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT 15568 { 15569 VULKAN_HPP_ASSERT( 15570 getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV && 15571 "Function <vkCmdWriteAccelerationStructuresPropertiesNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15572 15573 getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV( 15574 static_cast<VkCommandBuffer>( m_commandBuffer ), 15575 accelerationStructures.size(), 15576 reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ), 15577 static_cast<VkQueryType>( queryType ), 15578 static_cast<VkQueryPool>( queryPool ), 15579 firstQuery ); 15580 } 15581 compileDeferredNV(uint32_t shader) const15582 VULKAN_HPP_INLINE void Pipeline::compileDeferredNV( uint32_t shader ) const 15583 { 15584 VULKAN_HPP_ASSERT( getDispatcher()->vkCompileDeferredNV && 15585 "Function <vkCompileDeferredNV> needs extension <VK_NV_ray_tracing> enabled!" ); 15586 15587 VULKAN_HPP_NAMESPACE::Result result = 15588 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCompileDeferredNV( 15589 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), shader ) ); 15590 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15591 { 15592 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::compileDeferredNV" ); 15593 } 15594 } 15595 15596 //=== VK_KHR_maintenance3 === 15597 15598 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo) const15599 Device::getDescriptorSetLayoutSupportKHR( 15600 const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 15601 { 15602 VULKAN_HPP_ASSERT( 15603 getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && 15604 "Function <vkGetDescriptorSetLayoutSupportKHR> needs extension <VK_KHR_maintenance3> enabled!" ); 15605 15606 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; 15607 getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( 15608 static_cast<VkDevice>( m_device ), 15609 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 15610 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); 15611 return support; 15612 } 15613 15614 template <typename X, typename Y, typename... Z> getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo) const15615 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getDescriptorSetLayoutSupportKHR( 15616 const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 15617 { 15618 VULKAN_HPP_ASSERT( 15619 getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && 15620 "Function <vkGetDescriptorSetLayoutSupportKHR> needs extension <VK_KHR_maintenance3> enabled!" ); 15621 15622 StructureChain<X, Y, Z...> structureChain; 15623 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = 15624 structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); 15625 getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( 15626 static_cast<VkDevice>( m_device ), 15627 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 15628 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); 15629 return structureChain; 15630 } 15631 15632 //=== VK_KHR_draw_indirect_count === 15633 drawIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::Buffer countBuffer,VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const15634 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 15635 VULKAN_HPP_NAMESPACE::DeviceSize offset, 15636 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 15637 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 15638 uint32_t maxDrawCount, 15639 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 15640 { 15641 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountKHR && 15642 "Function <vkCmdDrawIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" ); 15643 15644 getDispatcher()->vkCmdDrawIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 15645 static_cast<VkBuffer>( buffer ), 15646 static_cast<VkDeviceSize>( offset ), 15647 static_cast<VkBuffer>( countBuffer ), 15648 static_cast<VkDeviceSize>( countBufferOffset ), 15649 maxDrawCount, 15650 stride ); 15651 } 15652 15653 VULKAN_HPP_INLINE void drawIndexedIndirectCountKHR(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::Buffer countBuffer,VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const15654 CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 15655 VULKAN_HPP_NAMESPACE::DeviceSize offset, 15656 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 15657 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 15658 uint32_t maxDrawCount, 15659 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 15660 { 15661 VULKAN_HPP_ASSERT( 15662 getDispatcher()->vkCmdDrawIndexedIndirectCountKHR && 15663 "Function <vkCmdDrawIndexedIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" ); 15664 15665 getDispatcher()->vkCmdDrawIndexedIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 15666 static_cast<VkBuffer>( buffer ), 15667 static_cast<VkDeviceSize>( offset ), 15668 static_cast<VkBuffer>( countBuffer ), 15669 static_cast<VkDeviceSize>( countBufferOffset ), 15670 maxDrawCount, 15671 stride ); 15672 } 15673 15674 //=== VK_EXT_external_memory_host === 15675 15676 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT getMemoryHostPointerPropertiesEXT(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,const void * pHostPointer) const15677 Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, 15678 const void * pHostPointer ) const 15679 { 15680 VULKAN_HPP_ASSERT( 15681 getDispatcher()->vkGetMemoryHostPointerPropertiesEXT && 15682 "Function <vkGetMemoryHostPointerPropertiesEXT> needs extension <VK_EXT_external_memory_host> enabled!" ); 15683 15684 VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties; 15685 VULKAN_HPP_NAMESPACE::Result result = 15686 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryHostPointerPropertiesEXT( 15687 static_cast<VkDevice>( m_device ), 15688 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), 15689 pHostPointer, 15690 reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) ) ); 15691 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15692 { 15693 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); 15694 } 15695 return memoryHostPointerProperties; 15696 } 15697 15698 //=== VK_AMD_buffer_marker === 15699 15700 VULKAN_HPP_INLINE void writeBufferMarkerAMD(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,uint32_t marker) const15701 CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, 15702 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 15703 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 15704 uint32_t marker ) const VULKAN_HPP_NOEXCEPT 15705 { 15706 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarkerAMD && 15707 "Function <vkCmdWriteBufferMarkerAMD> needs extension <VK_AMD_buffer_marker> enabled!" ); 15708 15709 getDispatcher()->vkCmdWriteBufferMarkerAMD( static_cast<VkCommandBuffer>( m_commandBuffer ), 15710 static_cast<VkPipelineStageFlagBits>( pipelineStage ), 15711 static_cast<VkBuffer>( dstBuffer ), 15712 static_cast<VkDeviceSize>( dstOffset ), 15713 marker ); 15714 } 15715 15716 //=== VK_EXT_calibrated_timestamps === 15717 15718 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> getCalibrateableTimeDomainsEXT() const15719 PhysicalDevice::getCalibrateableTimeDomainsEXT() const 15720 { 15721 VULKAN_HPP_ASSERT( 15722 getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && 15723 "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" ); 15724 15725 std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> timeDomains; 15726 uint32_t timeDomainCount; 15727 VULKAN_HPP_NAMESPACE::Result result; 15728 do 15729 { 15730 result = 15731 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( 15732 static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr ) ); 15733 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount ) 15734 { 15735 timeDomains.resize( timeDomainCount ); 15736 result = 15737 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( 15738 static_cast<VkPhysicalDevice>( m_physicalDevice ), 15739 &timeDomainCount, 15740 reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) ) ); 15741 } 15742 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15743 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15744 { 15745 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); 15746 } 15747 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15748 { 15749 VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); 15750 if ( timeDomainCount < timeDomains.size() ) 15751 { 15752 timeDomains.resize( timeDomainCount ); 15753 } 15754 } 15755 return timeDomains; 15756 } 15757 15758 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t> getCalibratedTimestampsEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos) const15759 Device::getCalibratedTimestampsEXT( 15760 ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos ) const 15761 { 15762 VULKAN_HPP_ASSERT( 15763 getDispatcher()->vkGetCalibratedTimestampsEXT && 15764 "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" ); 15765 15766 std::pair<std::vector<uint64_t>, uint64_t> data( 15767 std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); 15768 std::vector<uint64_t> & timestamps = data.first; 15769 uint64_t & maxDeviation = data.second; 15770 VULKAN_HPP_NAMESPACE::Result result = 15771 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsEXT( 15772 static_cast<VkDevice>( m_device ), 15773 timestampInfos.size(), 15774 reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ), 15775 timestamps.data(), 15776 &maxDeviation ) ); 15777 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15778 { 15779 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); 15780 } 15781 return data; 15782 } 15783 15784 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t> getCalibratedTimestampEXT(const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo) const15785 Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo ) const 15786 { 15787 VULKAN_HPP_ASSERT( 15788 getDispatcher()->vkGetCalibratedTimestampsEXT && 15789 "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" ); 15790 15791 std::pair<uint64_t, uint64_t> data; 15792 uint64_t & timestamp = data.first; 15793 uint64_t & maxDeviation = data.second; 15794 VULKAN_HPP_NAMESPACE::Result result = 15795 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsEXT( 15796 static_cast<VkDevice>( m_device ), 15797 1, 15798 reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( ×tampInfo ), 15799 ×tamp, 15800 &maxDeviation ) ); 15801 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15802 { 15803 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); 15804 } 15805 return data; 15806 } 15807 15808 //=== VK_NV_mesh_shader === 15809 drawMeshTasksNV(uint32_t taskCount,uint32_t firstTask) const15810 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, 15811 uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT 15812 { 15813 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksNV && 15814 "Function <vkCmdDrawMeshTasksNV> needs extension <VK_NV_mesh_shader> enabled!" ); 15815 15816 getDispatcher()->vkCmdDrawMeshTasksNV( static_cast<VkCommandBuffer>( m_commandBuffer ), taskCount, firstTask ); 15817 } 15818 drawMeshTasksIndirectNV(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,uint32_t drawCount,uint32_t stride) const15819 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, 15820 VULKAN_HPP_NAMESPACE::DeviceSize offset, 15821 uint32_t drawCount, 15822 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 15823 { 15824 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectNV && 15825 "Function <vkCmdDrawMeshTasksIndirectNV> needs extension <VK_NV_mesh_shader> enabled!" ); 15826 15827 getDispatcher()->vkCmdDrawMeshTasksIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 15828 static_cast<VkBuffer>( buffer ), 15829 static_cast<VkDeviceSize>( offset ), 15830 drawCount, 15831 stride ); 15832 } 15833 15834 VULKAN_HPP_INLINE void drawMeshTasksIndirectCountNV(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::Buffer countBuffer,VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const15835 CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, 15836 VULKAN_HPP_NAMESPACE::DeviceSize offset, 15837 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 15838 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 15839 uint32_t maxDrawCount, 15840 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 15841 { 15842 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV && 15843 "Function <vkCmdDrawMeshTasksIndirectCountNV> needs extension <VK_NV_mesh_shader> enabled!" ); 15844 15845 getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 15846 static_cast<VkBuffer>( buffer ), 15847 static_cast<VkDeviceSize>( offset ), 15848 static_cast<VkBuffer>( countBuffer ), 15849 static_cast<VkDeviceSize>( countBufferOffset ), 15850 maxDrawCount, 15851 stride ); 15852 } 15853 15854 //=== VK_NV_scissor_exclusive === 15855 setExclusiveScissorNV(uint32_t firstExclusiveScissor,ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors) const15856 VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( 15857 uint32_t firstExclusiveScissor, 15858 ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT 15859 { 15860 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorNV && 15861 "Function <vkCmdSetExclusiveScissorNV> needs extension <VK_NV_scissor_exclusive> enabled!" ); 15862 15863 getDispatcher()->vkCmdSetExclusiveScissorNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 15864 firstExclusiveScissor, 15865 exclusiveScissors.size(), 15866 reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) ); 15867 } 15868 15869 //=== VK_NV_device_diagnostic_checkpoints === 15870 setCheckpointNV(const void * pCheckpointMarker) const15871 VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT 15872 { 15873 VULKAN_HPP_ASSERT( 15874 getDispatcher()->vkCmdSetCheckpointNV && 15875 "Function <vkCmdSetCheckpointNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" ); 15876 15877 getDispatcher()->vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ), pCheckpointMarker ); 15878 } 15879 15880 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> getCheckpointDataNV() const15881 Queue::getCheckpointDataNV() const VULKAN_HPP_NOEXCEPT 15882 { 15883 VULKAN_HPP_ASSERT( 15884 getDispatcher()->vkGetQueueCheckpointDataNV && 15885 "Function <vkGetQueueCheckpointDataNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" ); 15886 15887 uint32_t checkpointDataCount; 15888 getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr ); 15889 std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> checkpointData( checkpointDataCount ); 15890 getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), 15891 &checkpointDataCount, 15892 reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) ); 15893 VULKAN_HPP_ASSERT( checkpointDataCount == checkpointData.size() ); 15894 return checkpointData; 15895 } 15896 15897 //=== VK_KHR_timeline_semaphore === 15898 getCounterValueKHR() const15899 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValueKHR() const 15900 { 15901 VULKAN_HPP_ASSERT( 15902 getDispatcher()->vkGetSemaphoreCounterValueKHR && 15903 "Function <vkGetSemaphoreCounterValueKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" ); 15904 15905 uint64_t value; 15906 VULKAN_HPP_NAMESPACE::Result result = 15907 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreCounterValueKHR( 15908 static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) ); 15909 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15910 { 15911 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" ); 15912 } 15913 return value; 15914 } 15915 15916 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,uint64_t timeout) const15917 Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const 15918 { 15919 VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphoresKHR && 15920 "Function <vkWaitSemaphoresKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" ); 15921 15922 VULKAN_HPP_NAMESPACE::Result result = 15923 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitSemaphoresKHR( 15924 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) ); 15925 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 15926 ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) ) 15927 { 15928 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR" ); 15929 } 15930 return result; 15931 } 15932 15933 VULKAN_HPP_INLINE void signalSemaphoreKHR(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo) const15934 Device::signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const 15935 { 15936 VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphoreKHR && 15937 "Function <vkSignalSemaphoreKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" ); 15938 15939 VULKAN_HPP_NAMESPACE::Result result = 15940 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSignalSemaphoreKHR( 15941 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) ); 15942 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15943 { 15944 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); 15945 } 15946 } 15947 15948 //=== VK_INTEL_performance_query === 15949 initializePerformanceApiINTEL(const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo) const15950 VULKAN_HPP_INLINE void Device::initializePerformanceApiINTEL( 15951 const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo ) const 15952 { 15953 VULKAN_HPP_ASSERT( 15954 getDispatcher()->vkInitializePerformanceApiINTEL && 15955 "Function <vkInitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" ); 15956 15957 VULKAN_HPP_NAMESPACE::Result result = 15958 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInitializePerformanceApiINTEL( 15959 static_cast<VkDevice>( m_device ), 15960 reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) ); 15961 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15962 { 15963 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); 15964 } 15965 } 15966 uninitializePerformanceApiINTEL() const15967 VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT 15968 { 15969 VULKAN_HPP_ASSERT( 15970 getDispatcher()->vkUninitializePerformanceApiINTEL && 15971 "Function <vkUninitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" ); 15972 15973 getDispatcher()->vkUninitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ) ); 15974 } 15975 setPerformanceMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo) const15976 VULKAN_HPP_INLINE void CommandBuffer::setPerformanceMarkerINTEL( 15977 const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo ) const 15978 { 15979 VULKAN_HPP_ASSERT( 15980 getDispatcher()->vkCmdSetPerformanceMarkerINTEL && 15981 "Function <vkCmdSetPerformanceMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" ); 15982 15983 VULKAN_HPP_NAMESPACE::Result result = 15984 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceMarkerINTEL( 15985 static_cast<VkCommandBuffer>( m_commandBuffer ), 15986 reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) ); 15987 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15988 { 15989 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); 15990 } 15991 } 15992 setPerformanceStreamMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo) const15993 VULKAN_HPP_INLINE void CommandBuffer::setPerformanceStreamMarkerINTEL( 15994 const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo ) const 15995 { 15996 VULKAN_HPP_ASSERT( 15997 getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL && 15998 "Function <vkCmdSetPerformanceStreamMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" ); 15999 16000 VULKAN_HPP_NAMESPACE::Result result = 16001 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL( 16002 static_cast<VkCommandBuffer>( m_commandBuffer ), 16003 reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) ); 16004 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16005 { 16006 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); 16007 } 16008 } 16009 setPerformanceOverrideINTEL(const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo) const16010 VULKAN_HPP_INLINE void CommandBuffer::setPerformanceOverrideINTEL( 16011 const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo ) const 16012 { 16013 VULKAN_HPP_ASSERT( 16014 getDispatcher()->vkCmdSetPerformanceOverrideINTEL && 16015 "Function <vkCmdSetPerformanceOverrideINTEL> needs extension <VK_INTEL_performance_query> enabled!" ); 16016 16017 VULKAN_HPP_NAMESPACE::Result result = 16018 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceOverrideINTEL( 16019 static_cast<VkCommandBuffer>( m_commandBuffer ), 16020 reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) ); 16021 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16022 { 16023 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); 16024 } 16025 } 16026 16027 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL acquirePerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo) const16028 Device::acquirePerformanceConfigurationINTEL( 16029 VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const 16030 { 16031 return VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL( *this, acquireInfo ); 16032 } 16033 16034 VULKAN_HPP_INLINE void setPerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration) const16035 Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const 16036 { 16037 VULKAN_HPP_ASSERT( 16038 getDispatcher()->vkQueueSetPerformanceConfigurationINTEL && 16039 "Function <vkQueueSetPerformanceConfigurationINTEL> needs extension <VK_INTEL_performance_query> enabled!" ); 16040 16041 VULKAN_HPP_NAMESPACE::Result result = 16042 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL( 16043 static_cast<VkQueue>( m_queue ), static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); 16044 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16045 { 16046 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); 16047 } 16048 } 16049 16050 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PerformanceValueINTEL getPerformanceParameterINTEL(VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter) const16051 Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const 16052 { 16053 VULKAN_HPP_ASSERT( 16054 getDispatcher()->vkGetPerformanceParameterINTEL && 16055 "Function <vkGetPerformanceParameterINTEL> needs extension <VK_INTEL_performance_query> enabled!" ); 16056 16057 VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value; 16058 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16059 getDispatcher()->vkGetPerformanceParameterINTEL( static_cast<VkDevice>( m_device ), 16060 static_cast<VkPerformanceParameterTypeINTEL>( parameter ), 16061 reinterpret_cast<VkPerformanceValueINTEL *>( &value ) ) ); 16062 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16063 { 16064 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); 16065 } 16066 return value; 16067 } 16068 16069 //=== VK_AMD_display_native_hdr === 16070 16071 VULKAN_HPP_INLINE void setLocalDimmingAMD(VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable) const16072 SwapchainKHR::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT 16073 { 16074 VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD && 16075 "Function <vkSetLocalDimmingAMD> needs extension <VK_AMD_display_native_hdr> enabled!" ); 16076 16077 getDispatcher()->vkSetLocalDimmingAMD( static_cast<VkDevice>( m_device ), 16078 static_cast<VkSwapchainKHR>( m_swapchain ), 16079 static_cast<VkBool32>( localDimmingEnable ) ); 16080 } 16081 16082 # if defined( VK_USE_PLATFORM_FUCHSIA ) 16083 //=== VK_FUCHSIA_imagepipe_surface === 16084 16085 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR createImagePipeSurfaceFUCHSIA(VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16086 Instance::createImagePipeSurfaceFUCHSIA( 16087 VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, 16088 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16089 { 16090 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 16091 } 16092 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 16093 16094 # if defined( VK_USE_PLATFORM_METAL_EXT ) 16095 //=== VK_EXT_metal_surface === 16096 createMetalSurfaceEXT(VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16097 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createMetalSurfaceEXT( 16098 VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo, 16099 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16100 { 16101 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 16102 } 16103 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 16104 16105 //=== VK_KHR_fragment_shading_rate === 16106 16107 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> getFragmentShadingRatesKHR() const16108 PhysicalDevice::getFragmentShadingRatesKHR() const 16109 { 16110 VULKAN_HPP_ASSERT( 16111 getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR && 16112 "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" ); 16113 16114 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> fragmentShadingRates; 16115 uint32_t fragmentShadingRateCount; 16116 VULKAN_HPP_NAMESPACE::Result result; 16117 do 16118 { 16119 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( 16120 static_cast<VkPhysicalDevice>( m_physicalDevice ), &fragmentShadingRateCount, nullptr ) ); 16121 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && fragmentShadingRateCount ) 16122 { 16123 fragmentShadingRates.resize( fragmentShadingRateCount ); 16124 result = 16125 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( 16126 static_cast<VkPhysicalDevice>( m_physicalDevice ), 16127 &fragmentShadingRateCount, 16128 reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) ); 16129 } 16130 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16131 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16132 { 16133 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); 16134 } 16135 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16136 { 16137 VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); 16138 if ( fragmentShadingRateCount < fragmentShadingRates.size() ) 16139 { 16140 fragmentShadingRates.resize( fragmentShadingRateCount ); 16141 } 16142 } 16143 return fragmentShadingRates; 16144 } 16145 setFragmentShadingRateKHR(const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize,const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2]) const16146 VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( 16147 const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize, 16148 const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT 16149 { 16150 VULKAN_HPP_ASSERT( 16151 getDispatcher()->vkCmdSetFragmentShadingRateKHR && 16152 "Function <vkCmdSetFragmentShadingRateKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" ); 16153 16154 getDispatcher()->vkCmdSetFragmentShadingRateKHR( 16155 static_cast<VkCommandBuffer>( m_commandBuffer ), 16156 reinterpret_cast<const VkExtent2D *>( &fragmentSize ), 16157 reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); 16158 } 16159 16160 //=== VK_EXT_buffer_device_address === 16161 getBufferAddressEXT(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const16162 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddressEXT( 16163 const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 16164 { 16165 VULKAN_HPP_ASSERT( 16166 getDispatcher()->vkGetBufferDeviceAddressEXT && 16167 "Function <vkGetBufferDeviceAddressEXT> needs extension <VK_EXT_buffer_device_address> enabled!" ); 16168 16169 return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( getDispatcher()->vkGetBufferDeviceAddressEXT( 16170 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ) ); 16171 } 16172 16173 //=== VK_EXT_tooling_info === 16174 16175 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT> getToolPropertiesEXT() const16176 PhysicalDevice::getToolPropertiesEXT() const 16177 { 16178 VULKAN_HPP_ASSERT( 16179 getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT && 16180 "Function <vkGetPhysicalDeviceToolPropertiesEXT> needs extension <VK_EXT_tooling_info> enabled!" ); 16181 16182 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT> toolProperties; 16183 uint32_t toolCount; 16184 VULKAN_HPP_NAMESPACE::Result result; 16185 do 16186 { 16187 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( 16188 static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, nullptr ) ); 16189 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount ) 16190 { 16191 toolProperties.resize( toolCount ); 16192 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( 16193 static_cast<VkPhysicalDevice>( m_physicalDevice ), 16194 &toolCount, 16195 reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( toolProperties.data() ) ) ); 16196 } 16197 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16198 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16199 { 16200 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); 16201 } 16202 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16203 { 16204 VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); 16205 if ( toolCount < toolProperties.size() ) 16206 { 16207 toolProperties.resize( toolCount ); 16208 } 16209 } 16210 return toolProperties; 16211 } 16212 16213 //=== VK_KHR_present_wait === 16214 16215 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result waitForPresent(uint64_t presentId,uint64_t timeout) const16216 SwapchainKHR::waitForPresent( uint64_t presentId, uint64_t timeout ) const 16217 { 16218 VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForPresentKHR && 16219 "Function <vkWaitForPresentKHR> needs extension <VK_KHR_present_wait> enabled!" ); 16220 16221 VULKAN_HPP_NAMESPACE::Result result = 16222 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitForPresentKHR( 16223 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), presentId, timeout ) ); 16224 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 16225 ( result != VULKAN_HPP_NAMESPACE::Result::eTimeout ) ) 16226 { 16227 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::waitForPresent" ); 16228 } 16229 return result; 16230 } 16231 16232 //=== VK_NV_cooperative_matrix === 16233 16234 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> getCooperativeMatrixPropertiesNV() const16235 PhysicalDevice::getCooperativeMatrixPropertiesNV() const 16236 { 16237 VULKAN_HPP_ASSERT( 16238 getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && 16239 "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> needs extension <VK_NV_cooperative_matrix> enabled!" ); 16240 16241 std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> properties; 16242 uint32_t propertyCount; 16243 VULKAN_HPP_NAMESPACE::Result result; 16244 do 16245 { 16246 result = 16247 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( 16248 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 16249 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 16250 { 16251 properties.resize( propertyCount ); 16252 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16253 getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( 16254 static_cast<VkPhysicalDevice>( m_physicalDevice ), 16255 &propertyCount, 16256 reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) ); 16257 } 16258 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16259 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16260 { 16261 throwResultException( result, 16262 VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); 16263 } 16264 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16265 { 16266 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 16267 if ( propertyCount < properties.size() ) 16268 { 16269 properties.resize( propertyCount ); 16270 } 16271 } 16272 return properties; 16273 } 16274 16275 //=== VK_NV_coverage_reduction_mode === 16276 16277 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> getSupportedFramebufferMixedSamplesCombinationsNV() const16278 PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV() const 16279 { 16280 VULKAN_HPP_ASSERT( 16281 getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && 16282 "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> needs extension <VK_NV_coverage_reduction_mode> enabled!" ); 16283 16284 std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> combinations; 16285 uint32_t combinationCount; 16286 VULKAN_HPP_NAMESPACE::Result result; 16287 do 16288 { 16289 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16290 getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 16291 static_cast<VkPhysicalDevice>( m_physicalDevice ), &combinationCount, nullptr ) ); 16292 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && combinationCount ) 16293 { 16294 combinations.resize( combinationCount ); 16295 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16296 getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 16297 static_cast<VkPhysicalDevice>( m_physicalDevice ), 16298 &combinationCount, 16299 reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) ); 16300 } 16301 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16302 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16303 { 16304 throwResultException( 16305 result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); 16306 } 16307 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16308 { 16309 VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); 16310 if ( combinationCount < combinations.size() ) 16311 { 16312 combinations.resize( combinationCount ); 16313 } 16314 } 16315 return combinations; 16316 } 16317 16318 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 16319 //=== VK_EXT_full_screen_exclusive === 16320 16321 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> getSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const16322 PhysicalDevice::getSurfacePresentModes2EXT( 16323 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 16324 { 16325 VULKAN_HPP_ASSERT( 16326 getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT && 16327 "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" ); 16328 16329 std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes; 16330 uint32_t presentModeCount; 16331 VULKAN_HPP_NAMESPACE::Result result; 16332 do 16333 { 16334 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( 16335 static_cast<VkPhysicalDevice>( m_physicalDevice ), 16336 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 16337 &presentModeCount, 16338 nullptr ) ); 16339 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount ) 16340 { 16341 presentModes.resize( presentModeCount ); 16342 result = 16343 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( 16344 static_cast<VkPhysicalDevice>( m_physicalDevice ), 16345 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 16346 &presentModeCount, 16347 reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); 16348 } 16349 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16350 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16351 { 16352 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); 16353 } 16354 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16355 { 16356 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); 16357 if ( presentModeCount < presentModes.size() ) 16358 { 16359 presentModes.resize( presentModeCount ); 16360 } 16361 } 16362 return presentModes; 16363 } 16364 acquireFullScreenExclusiveModeEXT() const16365 VULKAN_HPP_INLINE void SwapchainKHR::acquireFullScreenExclusiveModeEXT() const 16366 { 16367 VULKAN_HPP_ASSERT( 16368 getDispatcher()->vkAcquireFullScreenExclusiveModeEXT && 16369 "Function <vkAcquireFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" ); 16370 16371 VULKAN_HPP_NAMESPACE::Result result = 16372 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( 16373 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) ); 16374 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16375 { 16376 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" ); 16377 } 16378 } 16379 releaseFullScreenExclusiveModeEXT() const16380 VULKAN_HPP_INLINE void SwapchainKHR::releaseFullScreenExclusiveModeEXT() const 16381 { 16382 VULKAN_HPP_ASSERT( 16383 getDispatcher()->vkReleaseFullScreenExclusiveModeEXT && 16384 "Function <vkReleaseFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" ); 16385 16386 VULKAN_HPP_NAMESPACE::Result result = 16387 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( 16388 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) ); 16389 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16390 { 16391 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" ); 16392 } 16393 } 16394 16395 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR getGroupSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const16396 Device::getGroupSurfacePresentModes2EXT( 16397 const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 16398 { 16399 VULKAN_HPP_ASSERT( 16400 getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT && 16401 "Function <vkGetDeviceGroupSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" ); 16402 16403 VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; 16404 VULKAN_HPP_NAMESPACE::Result result = 16405 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT( 16406 static_cast<VkDevice>( m_device ), 16407 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 16408 reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) ); 16409 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16410 { 16411 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); 16412 } 16413 return modes; 16414 } 16415 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 16416 16417 //=== VK_EXT_headless_surface === 16418 createHeadlessSurfaceEXT(VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16419 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createHeadlessSurfaceEXT( 16420 VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo, 16421 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16422 { 16423 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 16424 } 16425 16426 //=== VK_KHR_buffer_device_address === 16427 getBufferAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const16428 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress Device::getBufferAddressKHR( 16429 const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 16430 { 16431 VULKAN_HPP_ASSERT( 16432 getDispatcher()->vkGetBufferDeviceAddressKHR && 16433 "Function <vkGetBufferDeviceAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" ); 16434 16435 return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( getDispatcher()->vkGetBufferDeviceAddressKHR( 16436 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ) ); 16437 } 16438 getBufferOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const16439 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( 16440 const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 16441 { 16442 VULKAN_HPP_ASSERT( 16443 getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR && 16444 "Function <vkGetBufferOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" ); 16445 16446 return getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR( 16447 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); 16448 } 16449 getMemoryOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info) const16450 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( 16451 const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 16452 { 16453 VULKAN_HPP_ASSERT( 16454 getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR && 16455 "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" ); 16456 16457 return getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR( 16458 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) ); 16459 } 16460 16461 //=== VK_EXT_line_rasterization === 16462 setLineStippleEXT(uint32_t lineStippleFactor,uint16_t lineStipplePattern) const16463 VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, 16464 uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT 16465 { 16466 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT && 16467 "Function <vkCmdSetLineStippleEXT> needs extension <VK_EXT_line_rasterization> enabled!" ); 16468 16469 getDispatcher()->vkCmdSetLineStippleEXT( 16470 static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); 16471 } 16472 16473 //=== VK_EXT_host_query_reset === 16474 resetEXT(uint32_t firstQuery,uint32_t queryCount) const16475 VULKAN_HPP_INLINE void QueryPool::resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT 16476 { 16477 VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPoolEXT && 16478 "Function <vkResetQueryPoolEXT> needs extension <VK_EXT_host_query_reset> enabled!" ); 16479 16480 getDispatcher()->vkResetQueryPoolEXT( 16481 static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount ); 16482 } 16483 16484 //=== VK_EXT_extended_dynamic_state === 16485 16486 VULKAN_HPP_INLINE void setCullModeEXT(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode) const16487 CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT 16488 { 16489 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullModeEXT && 16490 "Function <vkCmdSetCullModeEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16491 16492 getDispatcher()->vkCmdSetCullModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16493 static_cast<VkCullModeFlags>( cullMode ) ); 16494 } 16495 16496 VULKAN_HPP_INLINE void setFrontFaceEXT(VULKAN_HPP_NAMESPACE::FrontFace frontFace) const16497 CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT 16498 { 16499 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFaceEXT && 16500 "Function <vkCmdSetFrontFaceEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16501 16502 getDispatcher()->vkCmdSetFrontFaceEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16503 static_cast<VkFrontFace>( frontFace ) ); 16504 } 16505 setPrimitiveTopologyEXT(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology) const16506 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( 16507 VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT 16508 { 16509 VULKAN_HPP_ASSERT( 16510 getDispatcher()->vkCmdSetPrimitiveTopologyEXT && 16511 "Function <vkCmdSetPrimitiveTopologyEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16512 16513 getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16514 static_cast<VkPrimitiveTopology>( primitiveTopology ) ); 16515 } 16516 setViewportWithCountEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports) const16517 VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( 16518 ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT 16519 { 16520 VULKAN_HPP_ASSERT( 16521 getDispatcher()->vkCmdSetViewportWithCountEXT && 16522 "Function <vkCmdSetViewportWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16523 16524 getDispatcher()->vkCmdSetViewportWithCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16525 viewports.size(), 16526 reinterpret_cast<const VkViewport *>( viewports.data() ) ); 16527 } 16528 setScissorWithCountEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors) const16529 VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( 16530 ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT 16531 { 16532 VULKAN_HPP_ASSERT( 16533 getDispatcher()->vkCmdSetScissorWithCountEXT && 16534 "Function <vkCmdSetScissorWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16535 16536 getDispatcher()->vkCmdSetScissorWithCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16537 scissors.size(), 16538 reinterpret_cast<const VkRect2D *>( scissors.data() ) ); 16539 } 16540 bindVertexBuffers2EXT(uint32_t firstBinding,ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides) const16541 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( 16542 uint32_t firstBinding, 16543 ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 16544 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 16545 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, 16546 ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 16547 { 16548 VULKAN_HPP_ASSERT( 16549 getDispatcher()->vkCmdBindVertexBuffers2EXT && 16550 "Function <vkCmdBindVertexBuffers2EXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16551 16552 # ifdef VULKAN_HPP_NO_EXCEPTIONS 16553 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); 16554 VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); 16555 VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); 16556 # else 16557 if ( buffers.size() != offsets.size() ) 16558 { 16559 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 16560 "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); 16561 } 16562 if ( !sizes.empty() && buffers.size() != sizes.size() ) 16563 { 16564 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 16565 "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); 16566 } 16567 if ( !strides.empty() && buffers.size() != strides.size() ) 16568 { 16569 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 16570 "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); 16571 } 16572 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 16573 16574 getDispatcher()->vkCmdBindVertexBuffers2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16575 firstBinding, 16576 buffers.size(), 16577 reinterpret_cast<const VkBuffer *>( buffers.data() ), 16578 reinterpret_cast<const VkDeviceSize *>( offsets.data() ), 16579 reinterpret_cast<const VkDeviceSize *>( sizes.data() ), 16580 reinterpret_cast<const VkDeviceSize *>( strides.data() ) ); 16581 } 16582 16583 VULKAN_HPP_INLINE void setDepthTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable) const16584 CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT 16585 { 16586 VULKAN_HPP_ASSERT( 16587 getDispatcher()->vkCmdSetDepthTestEnableEXT && 16588 "Function <vkCmdSetDepthTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16589 16590 getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16591 static_cast<VkBool32>( depthTestEnable ) ); 16592 } 16593 16594 VULKAN_HPP_INLINE void setDepthWriteEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable) const16595 CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT 16596 { 16597 VULKAN_HPP_ASSERT( 16598 getDispatcher()->vkCmdSetDepthWriteEnableEXT && 16599 "Function <vkCmdSetDepthWriteEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16600 16601 getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16602 static_cast<VkBool32>( depthWriteEnable ) ); 16603 } 16604 16605 VULKAN_HPP_INLINE void setDepthCompareOpEXT(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp) const16606 CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT 16607 { 16608 VULKAN_HPP_ASSERT( 16609 getDispatcher()->vkCmdSetDepthCompareOpEXT && 16610 "Function <vkCmdSetDepthCompareOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16611 16612 getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16613 static_cast<VkCompareOp>( depthCompareOp ) ); 16614 } 16615 setDepthBoundsTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable) const16616 VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( 16617 VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT 16618 { 16619 VULKAN_HPP_ASSERT( 16620 getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT && 16621 "Function <vkCmdSetDepthBoundsTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16622 16623 getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16624 static_cast<VkBool32>( depthBoundsTestEnable ) ); 16625 } 16626 16627 VULKAN_HPP_INLINE void setStencilTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable) const16628 CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT 16629 { 16630 VULKAN_HPP_ASSERT( 16631 getDispatcher()->vkCmdSetStencilTestEnableEXT && 16632 "Function <vkCmdSetStencilTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16633 16634 getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16635 static_cast<VkBool32>( stencilTestEnable ) ); 16636 } 16637 16638 VULKAN_HPP_INLINE void setStencilOpEXT(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,VULKAN_HPP_NAMESPACE::StencilOp failOp,VULKAN_HPP_NAMESPACE::StencilOp passOp,VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,VULKAN_HPP_NAMESPACE::CompareOp compareOp) const16639 CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 16640 VULKAN_HPP_NAMESPACE::StencilOp failOp, 16641 VULKAN_HPP_NAMESPACE::StencilOp passOp, 16642 VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, 16643 VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT 16644 { 16645 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOpEXT && 16646 "Function <vkCmdSetStencilOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" ); 16647 16648 getDispatcher()->vkCmdSetStencilOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16649 static_cast<VkStencilFaceFlags>( faceMask ), 16650 static_cast<VkStencilOp>( failOp ), 16651 static_cast<VkStencilOp>( passOp ), 16652 static_cast<VkStencilOp>( depthFailOp ), 16653 static_cast<VkCompareOp>( compareOp ) ); 16654 } 16655 16656 //=== VK_KHR_deferred_host_operations === 16657 16658 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR createDeferredOperationKHR(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16659 Device::createDeferredOperationKHR( 16660 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16661 { 16662 return VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR( *this, allocator ); 16663 } 16664 getMaxConcurrency() const16665 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT 16666 { 16667 VULKAN_HPP_ASSERT( 16668 getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR && 16669 "Function <vkGetDeferredOperationMaxConcurrencyKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" ); 16670 16671 return getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( 16672 static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ); 16673 } 16674 16675 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result getResult() const16676 DeferredOperationKHR::getResult() const VULKAN_HPP_NOEXCEPT 16677 { 16678 VULKAN_HPP_ASSERT( 16679 getDispatcher()->vkGetDeferredOperationResultKHR && 16680 "Function <vkGetDeferredOperationResultKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" ); 16681 16682 return static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeferredOperationResultKHR( 16683 static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ) ); 16684 } 16685 join() const16686 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::join() const 16687 { 16688 VULKAN_HPP_ASSERT( 16689 getDispatcher()->vkDeferredOperationJoinKHR && 16690 "Function <vkDeferredOperationJoinKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" ); 16691 16692 VULKAN_HPP_NAMESPACE::Result result = 16693 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDeferredOperationJoinKHR( 16694 static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ) ); 16695 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 16696 ( result != VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR ) && 16697 ( result != VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR ) ) 16698 { 16699 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join" ); 16700 } 16701 return result; 16702 } 16703 16704 //=== VK_KHR_pipeline_executable_properties === 16705 16706 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> getPipelineExecutablePropertiesKHR(const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo) const16707 Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo ) const 16708 { 16709 VULKAN_HPP_ASSERT( 16710 getDispatcher()->vkGetPipelineExecutablePropertiesKHR && 16711 "Function <vkGetPipelineExecutablePropertiesKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" ); 16712 16713 std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> properties; 16714 uint32_t executableCount; 16715 VULKAN_HPP_NAMESPACE::Result result; 16716 do 16717 { 16718 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutablePropertiesKHR( 16719 static_cast<VkDevice>( m_device ), 16720 reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), 16721 &executableCount, 16722 nullptr ) ); 16723 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && executableCount ) 16724 { 16725 properties.resize( executableCount ); 16726 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutablePropertiesKHR( 16727 static_cast<VkDevice>( m_device ), 16728 reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), 16729 &executableCount, 16730 reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) ); 16731 } 16732 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16733 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16734 { 16735 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); 16736 } 16737 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16738 { 16739 VULKAN_HPP_ASSERT( executableCount <= properties.size() ); 16740 if ( executableCount < properties.size() ) 16741 { 16742 properties.resize( executableCount ); 16743 } 16744 } 16745 return properties; 16746 } 16747 16748 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> getPipelineExecutableStatisticsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo) const16749 Device::getPipelineExecutableStatisticsKHR( 16750 const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const 16751 { 16752 VULKAN_HPP_ASSERT( 16753 getDispatcher()->vkGetPipelineExecutableStatisticsKHR && 16754 "Function <vkGetPipelineExecutableStatisticsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" ); 16755 16756 std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> statistics; 16757 uint32_t statisticCount; 16758 VULKAN_HPP_NAMESPACE::Result result; 16759 do 16760 { 16761 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutableStatisticsKHR( 16762 static_cast<VkDevice>( m_device ), 16763 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), 16764 &statisticCount, 16765 nullptr ) ); 16766 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && statisticCount ) 16767 { 16768 statistics.resize( statisticCount ); 16769 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutableStatisticsKHR( 16770 static_cast<VkDevice>( m_device ), 16771 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), 16772 &statisticCount, 16773 reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) ); 16774 } 16775 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16776 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16777 { 16778 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); 16779 } 16780 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16781 { 16782 VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); 16783 if ( statisticCount < statistics.size() ) 16784 { 16785 statistics.resize( statisticCount ); 16786 } 16787 } 16788 return statistics; 16789 } 16790 16791 VULKAN_HPP_NODISCARD 16792 VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> getPipelineExecutableInternalRepresentationsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo) const16793 Device::getPipelineExecutableInternalRepresentationsKHR( 16794 const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const 16795 { 16796 VULKAN_HPP_ASSERT( 16797 getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR && 16798 "Function <vkGetPipelineExecutableInternalRepresentationsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" ); 16799 16800 std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> internalRepresentations; 16801 uint32_t internalRepresentationCount; 16802 VULKAN_HPP_NAMESPACE::Result result; 16803 do 16804 { 16805 result = 16806 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( 16807 static_cast<VkDevice>( m_device ), 16808 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), 16809 &internalRepresentationCount, 16810 nullptr ) ); 16811 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && internalRepresentationCount ) 16812 { 16813 internalRepresentations.resize( internalRepresentationCount ); 16814 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16815 getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( 16816 static_cast<VkDevice>( m_device ), 16817 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), 16818 &internalRepresentationCount, 16819 reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) ); 16820 } 16821 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16822 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16823 { 16824 throwResultException( result, 16825 VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); 16826 } 16827 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16828 { 16829 VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); 16830 if ( internalRepresentationCount < internalRepresentations.size() ) 16831 { 16832 internalRepresentations.resize( internalRepresentationCount ); 16833 } 16834 } 16835 return internalRepresentations; 16836 } 16837 16838 //=== VK_NV_device_generated_commands === 16839 16840 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info) const16841 Device::getGeneratedCommandsMemoryRequirementsNV( 16842 const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT 16843 { 16844 VULKAN_HPP_ASSERT( 16845 getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && 16846 "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" ); 16847 16848 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 16849 getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( 16850 static_cast<VkDevice>( m_device ), 16851 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ), 16852 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 16853 return memoryRequirements; 16854 } 16855 16856 template <typename X, typename Y, typename... Z> getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info) const16857 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getGeneratedCommandsMemoryRequirementsNV( 16858 const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT 16859 { 16860 VULKAN_HPP_ASSERT( 16861 getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && 16862 "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" ); 16863 16864 StructureChain<X, Y, Z...> structureChain; 16865 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = 16866 structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 16867 getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( 16868 static_cast<VkDevice>( m_device ), 16869 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ), 16870 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 16871 return structureChain; 16872 } 16873 preprocessGeneratedCommandsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo) const16874 VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( 16875 const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT 16876 { 16877 VULKAN_HPP_ASSERT( 16878 getDispatcher()->vkCmdPreprocessGeneratedCommandsNV && 16879 "Function <vkCmdPreprocessGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" ); 16880 16881 getDispatcher()->vkCmdPreprocessGeneratedCommandsNV( 16882 static_cast<VkCommandBuffer>( m_commandBuffer ), 16883 reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) ); 16884 } 16885 executeGeneratedCommandsNV(VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo) const16886 VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( 16887 VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, 16888 const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT 16889 { 16890 VULKAN_HPP_ASSERT( 16891 getDispatcher()->vkCmdExecuteGeneratedCommandsNV && 16892 "Function <vkCmdExecuteGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" ); 16893 16894 getDispatcher()->vkCmdExecuteGeneratedCommandsNV( 16895 static_cast<VkCommandBuffer>( m_commandBuffer ), 16896 static_cast<VkBool32>( isPreprocessed ), 16897 reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) ); 16898 } 16899 16900 VULKAN_HPP_INLINE void bindPipelineShaderGroupNV(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::Pipeline pipeline,uint32_t groupIndex) const16901 CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 16902 VULKAN_HPP_NAMESPACE::Pipeline pipeline, 16903 uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT 16904 { 16905 VULKAN_HPP_ASSERT( 16906 getDispatcher()->vkCmdBindPipelineShaderGroupNV && 16907 "Function <vkCmdBindPipelineShaderGroupNV> needs extension <VK_NV_device_generated_commands> enabled!" ); 16908 16909 getDispatcher()->vkCmdBindPipelineShaderGroupNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 16910 static_cast<VkPipelineBindPoint>( pipelineBindPoint ), 16911 static_cast<VkPipeline>( pipeline ), 16912 groupIndex ); 16913 } 16914 16915 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV createIndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16916 Device::createIndirectCommandsLayoutNV( 16917 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo, 16918 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16919 { 16920 return VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV( *this, createInfo, allocator ); 16921 } 16922 16923 //=== VK_EXT_acquire_drm_display === 16924 acquireDrmDisplayEXT(int32_t drmFd,VULKAN_HPP_NAMESPACE::DisplayKHR display) const16925 VULKAN_HPP_INLINE void PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, 16926 VULKAN_HPP_NAMESPACE::DisplayKHR display ) const 16927 { 16928 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireDrmDisplayEXT && 16929 "Function <vkAcquireDrmDisplayEXT> needs extension <VK_EXT_acquire_drm_display> enabled!" ); 16930 16931 VULKAN_HPP_NAMESPACE::Result result = 16932 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireDrmDisplayEXT( 16933 static_cast<VkPhysicalDevice>( m_physicalDevice ), drmFd, static_cast<VkDisplayKHR>( display ) ) ); 16934 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16935 { 16936 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); 16937 } 16938 } 16939 16940 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getDrmDisplayEXT(int32_t drmFd,uint32_t connectorId) const16941 PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const 16942 { 16943 return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, drmFd, connectorId ); 16944 } 16945 16946 //=== VK_EXT_private_data === 16947 16948 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlotEXT createPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16949 Device::createPrivateDataSlotEXT( 16950 VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT const & createInfo, 16951 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16952 { 16953 return VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlotEXT( *this, createInfo, allocator ); 16954 } 16955 setPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType_,uint64_t objectHandle,VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,uint64_t data) const16956 VULKAN_HPP_INLINE void Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 16957 uint64_t objectHandle, 16958 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot, 16959 uint64_t data ) const 16960 { 16961 VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateDataEXT && 16962 "Function <vkSetPrivateDataEXT> needs extension <VK_EXT_private_data> enabled!" ); 16963 16964 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16965 getDispatcher()->vkSetPrivateDataEXT( static_cast<VkDevice>( m_device ), 16966 static_cast<VkObjectType>( objectType_ ), 16967 objectHandle, 16968 static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), 16969 data ) ); 16970 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16971 { 16972 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); 16973 } 16974 } 16975 16976 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t getPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType_,uint64_t objectHandle,VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot) const16977 Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 16978 uint64_t objectHandle, 16979 VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot ) const VULKAN_HPP_NOEXCEPT 16980 { 16981 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateDataEXT && 16982 "Function <vkGetPrivateDataEXT> needs extension <VK_EXT_private_data> enabled!" ); 16983 16984 uint64_t data; 16985 getDispatcher()->vkGetPrivateDataEXT( static_cast<VkDevice>( m_device ), 16986 static_cast<VkObjectType>( objectType_ ), 16987 objectHandle, 16988 static_cast<VkPrivateDataSlotEXT>( privateDataSlot ), 16989 &data ); 16990 return data; 16991 } 16992 16993 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 16994 //=== VK_KHR_video_encode_queue === 16995 encodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo) const16996 VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( 16997 const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT 16998 { 16999 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEncodeVideoKHR && 17000 "Function <vkCmdEncodeVideoKHR> needs extension <VK_KHR_video_encode_queue> enabled!" ); 17001 17002 getDispatcher()->vkCmdEncodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17003 reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) ); 17004 } 17005 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 17006 17007 //=== VK_KHR_synchronization2 === 17008 setEvent2KHR(VULKAN_HPP_NAMESPACE::Event event,const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo) const17009 VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( 17010 VULKAN_HPP_NAMESPACE::Event event, 17011 const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 17012 { 17013 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2KHR && 17014 "Function <vkCmdSetEvent2KHR> needs extension <VK_KHR_synchronization2> enabled!" ); 17015 17016 getDispatcher()->vkCmdSetEvent2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17017 static_cast<VkEvent>( event ), 17018 reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) ); 17019 } 17020 17021 VULKAN_HPP_INLINE void resetEvent2KHR(VULKAN_HPP_NAMESPACE::Event event,VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask) const17022 CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, 17023 VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask ) const VULKAN_HPP_NOEXCEPT 17024 { 17025 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2KHR && 17026 "Function <vkCmdResetEvent2KHR> needs extension <VK_KHR_synchronization2> enabled!" ); 17027 17028 getDispatcher()->vkCmdResetEvent2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17029 static_cast<VkEvent>( event ), 17030 static_cast<VkPipelineStageFlags2KHR>( stageMask ) ); 17031 } 17032 17033 VULKAN_HPP_INLINE void waitEvents2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos) const17034 CommandBuffer::waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 17035 ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos ) 17036 const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 17037 { 17038 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2KHR && 17039 "Function <vkCmdWaitEvents2KHR> needs extension <VK_KHR_synchronization2> enabled!" ); 17040 17041 # ifdef VULKAN_HPP_NO_EXCEPTIONS 17042 VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); 17043 # else 17044 if ( events.size() != dependencyInfos.size() ) 17045 { 17046 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 17047 "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" ); 17048 } 17049 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 17050 17051 getDispatcher()->vkCmdWaitEvents2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17052 events.size(), 17053 reinterpret_cast<const VkEvent *>( events.data() ), 17054 reinterpret_cast<const VkDependencyInfoKHR *>( dependencyInfos.data() ) ); 17055 } 17056 pipelineBarrier2KHR(const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo) const17057 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( 17058 const VULKAN_HPP_NAMESPACE::DependencyInfoKHR & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 17059 { 17060 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2KHR && 17061 "Function <vkCmdPipelineBarrier2KHR> needs extension <VK_KHR_synchronization2> enabled!" ); 17062 17063 getDispatcher()->vkCmdPipelineBarrier2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17064 reinterpret_cast<const VkDependencyInfoKHR *>( &dependencyInfo ) ); 17065 } 17066 writeTimestamp2KHR(VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query) const17067 VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage, 17068 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 17069 uint32_t query ) const VULKAN_HPP_NOEXCEPT 17070 { 17071 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2KHR && 17072 "Function <vkCmdWriteTimestamp2KHR> needs extension <VK_KHR_synchronization2> enabled!" ); 17073 17074 getDispatcher()->vkCmdWriteTimestamp2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17075 static_cast<VkPipelineStageFlags2KHR>( stage ), 17076 static_cast<VkQueryPool>( queryPool ), 17077 query ); 17078 } 17079 submit2KHR(ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,VULKAN_HPP_NAMESPACE::Fence fence) const17080 VULKAN_HPP_INLINE void Queue::submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits, 17081 VULKAN_HPP_NAMESPACE::Fence fence ) const 17082 { 17083 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2KHR && 17084 "Function <vkQueueSubmit2KHR> needs extension <VK_KHR_synchronization2> enabled!" ); 17085 17086 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17087 getDispatcher()->vkQueueSubmit2KHR( static_cast<VkQueue>( m_queue ), 17088 submits.size(), 17089 reinterpret_cast<const VkSubmitInfo2KHR *>( submits.data() ), 17090 static_cast<VkFence>( fence ) ) ); 17091 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17092 { 17093 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" ); 17094 } 17095 } 17096 writeBufferMarker2AMD(VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,uint32_t marker) const17097 VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage, 17098 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 17099 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 17100 uint32_t marker ) const VULKAN_HPP_NOEXCEPT 17101 { 17102 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarker2AMD && 17103 "Function <vkCmdWriteBufferMarker2AMD> needs extension <VK_KHR_synchronization2> enabled!" ); 17104 17105 getDispatcher()->vkCmdWriteBufferMarker2AMD( static_cast<VkCommandBuffer>( m_commandBuffer ), 17106 static_cast<VkPipelineStageFlags2KHR>( stage ), 17107 static_cast<VkBuffer>( dstBuffer ), 17108 static_cast<VkDeviceSize>( dstOffset ), 17109 marker ); 17110 } 17111 17112 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> getCheckpointData2NV() const17113 Queue::getCheckpointData2NV() const VULKAN_HPP_NOEXCEPT 17114 { 17115 VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV && 17116 "Function <vkGetQueueCheckpointData2NV> needs extension <VK_KHR_synchronization2> enabled!" ); 17117 17118 uint32_t checkpointDataCount; 17119 getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr ); 17120 std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> checkpointData( checkpointDataCount ); 17121 getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), 17122 &checkpointDataCount, 17123 reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) ); 17124 VULKAN_HPP_ASSERT( checkpointDataCount == checkpointData.size() ); 17125 return checkpointData; 17126 } 17127 17128 //=== VK_NV_fragment_shading_rate_enums === 17129 setFragmentShadingRateEnumNV(VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate,const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2]) const17130 VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( 17131 VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, 17132 const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT 17133 { 17134 VULKAN_HPP_ASSERT( 17135 getDispatcher()->vkCmdSetFragmentShadingRateEnumNV && 17136 "Function <vkCmdSetFragmentShadingRateEnumNV> needs extension <VK_NV_fragment_shading_rate_enums> enabled!" ); 17137 17138 getDispatcher()->vkCmdSetFragmentShadingRateEnumNV( 17139 static_cast<VkCommandBuffer>( m_commandBuffer ), 17140 static_cast<VkFragmentShadingRateNV>( shadingRate ), 17141 reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); 17142 } 17143 17144 //=== VK_KHR_copy_commands2 === 17145 copyBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR & copyBufferInfo) const17146 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( 17147 const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT 17148 { 17149 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2KHR && 17150 "Function <vkCmdCopyBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!" ); 17151 17152 getDispatcher()->vkCmdCopyBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17153 reinterpret_cast<const VkCopyBufferInfo2KHR *>( ©BufferInfo ) ); 17154 } 17155 copyImage2KHR(const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR & copyImageInfo) const17156 VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( 17157 const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR & copyImageInfo ) const VULKAN_HPP_NOEXCEPT 17158 { 17159 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2KHR && 17160 "Function <vkCmdCopyImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" ); 17161 17162 getDispatcher()->vkCmdCopyImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17163 reinterpret_cast<const VkCopyImageInfo2KHR *>( ©ImageInfo ) ); 17164 } 17165 copyBufferToImage2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR & copyBufferToImageInfo) const17166 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( 17167 const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT 17168 { 17169 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2KHR && 17170 "Function <vkCmdCopyBufferToImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" ); 17171 17172 getDispatcher()->vkCmdCopyBufferToImage2KHR( 17173 static_cast<VkCommandBuffer>( m_commandBuffer ), 17174 reinterpret_cast<const VkCopyBufferToImageInfo2KHR *>( ©BufferToImageInfo ) ); 17175 } 17176 copyImageToBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR & copyImageToBufferInfo) const17177 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( 17178 const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT 17179 { 17180 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2KHR && 17181 "Function <vkCmdCopyImageToBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!" ); 17182 17183 getDispatcher()->vkCmdCopyImageToBuffer2KHR( 17184 static_cast<VkCommandBuffer>( m_commandBuffer ), 17185 reinterpret_cast<const VkCopyImageToBufferInfo2KHR *>( ©ImageToBufferInfo ) ); 17186 } 17187 blitImage2KHR(const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR & blitImageInfo) const17188 VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( 17189 const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR & blitImageInfo ) const VULKAN_HPP_NOEXCEPT 17190 { 17191 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2KHR && 17192 "Function <vkCmdBlitImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" ); 17193 17194 getDispatcher()->vkCmdBlitImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17195 reinterpret_cast<const VkBlitImageInfo2KHR *>( &blitImageInfo ) ); 17196 } 17197 resolveImage2KHR(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR & resolveImageInfo) const17198 VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( 17199 const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT 17200 { 17201 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2KHR && 17202 "Function <vkCmdResolveImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" ); 17203 17204 getDispatcher()->vkCmdResolveImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17205 reinterpret_cast<const VkResolveImageInfo2KHR *>( &resolveImageInfo ) ); 17206 } 17207 17208 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 17209 //=== VK_NV_acquire_winrt_display === 17210 acquireWinrtNV() const17211 VULKAN_HPP_INLINE void DisplayKHR::acquireWinrtNV() const 17212 { 17213 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireWinrtDisplayNV && 17214 "Function <vkAcquireWinrtDisplayNV> needs extension <VK_NV_acquire_winrt_display> enabled!" ); 17215 17216 VULKAN_HPP_NAMESPACE::Result result = 17217 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireWinrtDisplayNV( 17218 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) ) ); 17219 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17220 { 17221 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" ); 17222 } 17223 } 17224 17225 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getWinrtDisplayNV(uint32_t deviceRelativeId) const17226 PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId ) const 17227 { 17228 return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, deviceRelativeId ); 17229 } 17230 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 17231 17232 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 17233 //=== VK_EXT_directfb_surface === 17234 createDirectFBSurfaceEXT(VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17235 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createDirectFBSurfaceEXT( 17236 VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo, 17237 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17238 { 17239 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 17240 } 17241 17242 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT(uint32_t queueFamilyIndex,IDirectFB & dfb) const17243 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, 17244 IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT 17245 { 17246 VULKAN_HPP_ASSERT( 17247 getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT && 17248 "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> needs extension <VK_EXT_directfb_surface> enabled!" ); 17249 17250 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( 17251 getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT( 17252 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dfb ) ); 17253 } 17254 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 17255 17256 //=== VK_KHR_ray_tracing_pipeline === 17257 traceRaysKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,uint32_t width,uint32_t height,uint32_t depth) const17258 VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( 17259 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, 17260 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, 17261 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, 17262 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, 17263 uint32_t width, 17264 uint32_t height, 17265 uint32_t depth ) const VULKAN_HPP_NOEXCEPT 17266 { 17267 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysKHR && 17268 "Function <vkCmdTraceRaysKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" ); 17269 17270 getDispatcher()->vkCmdTraceRaysKHR( 17271 static_cast<VkCommandBuffer>( m_commandBuffer ), 17272 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ), 17273 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ), 17274 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ), 17275 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ), 17276 width, 17277 height, 17278 depth ); 17279 } 17280 17281 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createRayTracingPipelinesKHR(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17282 Device::createRayTracingPipelinesKHR( 17283 VULKAN_HPP_NAMESPACE::Optional< 17284 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 17285 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 17286 pipelineCache, 17287 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, 17288 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17289 { 17290 return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, deferredOperation, pipelineCache, createInfos, allocator ); 17291 } 17292 createRayTracingPipelineKHR(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17293 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Pipeline Device::createRayTracingPipelineKHR( 17294 VULKAN_HPP_NAMESPACE::Optional< 17295 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 17296 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & 17297 pipelineCache, 17298 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo, 17299 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17300 { 17301 return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, deferredOperation, pipelineCache, createInfo, allocator ); 17302 } 17303 17304 template <typename T> 17305 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> getRayTracingShaderGroupHandlesKHR(uint32_t firstGroup,uint32_t groupCount,size_t dataSize) const17306 Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const 17307 { 17308 VULKAN_HPP_ASSERT( 17309 getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR && 17310 "Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" ); 17311 17312 VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); 17313 std::vector<T> data( dataSize / sizeof( T ) ); 17314 Result result = static_cast<Result>( 17315 getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), 17316 static_cast<VkPipeline>( m_pipeline ), 17317 firstGroup, 17318 groupCount, 17319 data.size() * sizeof( T ), 17320 reinterpret_cast<void *>( data.data() ) ) ); 17321 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17322 { 17323 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesKHR" ); 17324 } 17325 return data; 17326 } 17327 17328 template <typename T> getRayTracingShaderGroupHandleKHR(uint32_t firstGroup,uint32_t groupCount) const17329 VULKAN_HPP_NODISCARD T Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const 17330 { 17331 T data; 17332 Result result = static_cast<Result>( 17333 getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), 17334 static_cast<VkPipeline>( m_pipeline ), 17335 firstGroup, 17336 groupCount, 17337 sizeof( T ), 17338 reinterpret_cast<void *>( &data ) ) ); 17339 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17340 { 17341 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleKHR" ); 17342 } 17343 return data; 17344 } 17345 17346 template <typename T> getRayTracingCaptureReplayShaderGroupHandlesKHR(uint32_t firstGroup,uint32_t groupCount,size_t dataSize) const17347 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<T> Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR( 17348 uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const 17349 { 17350 VULKAN_HPP_ASSERT( 17351 getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && 17352 "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" ); 17353 17354 VULKAN_HPP_ASSERT( dataSize % sizeof( T ) == 0 ); 17355 std::vector<T> data( dataSize / sizeof( T ) ); 17356 Result result = static_cast<Result>( 17357 getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), 17358 static_cast<VkPipeline>( m_pipeline ), 17359 firstGroup, 17360 groupCount, 17361 data.size() * sizeof( T ), 17362 reinterpret_cast<void *>( data.data() ) ) ); 17363 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17364 { 17365 throwResultException( 17366 result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); 17367 } 17368 return data; 17369 } 17370 17371 template <typename T> getRayTracingCaptureReplayShaderGroupHandleKHR(uint32_t firstGroup,uint32_t groupCount) const17372 VULKAN_HPP_NODISCARD T Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, 17373 uint32_t groupCount ) const 17374 { 17375 T data; 17376 Result result = static_cast<Result>( 17377 getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), 17378 static_cast<VkPipeline>( m_pipeline ), 17379 firstGroup, 17380 groupCount, 17381 sizeof( T ), 17382 reinterpret_cast<void *>( &data ) ) ); 17383 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17384 { 17385 throwResultException( 17386 result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR" ); 17387 } 17388 return data; 17389 } 17390 traceRaysIndirectKHR(const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress) const17391 VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( 17392 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, 17393 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, 17394 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, 17395 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, 17396 VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT 17397 { 17398 VULKAN_HPP_ASSERT( 17399 getDispatcher()->vkCmdTraceRaysIndirectKHR && 17400 "Function <vkCmdTraceRaysIndirectKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" ); 17401 17402 getDispatcher()->vkCmdTraceRaysIndirectKHR( 17403 static_cast<VkCommandBuffer>( m_commandBuffer ), 17404 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ), 17405 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ), 17406 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ), 17407 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ), 17408 static_cast<VkDeviceAddress>( indirectDeviceAddress ) ); 17409 } 17410 17411 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize getRayTracingShaderGroupStackSizeKHR(uint32_t group,VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader) const17412 Pipeline::getRayTracingShaderGroupStackSizeKHR( 17413 uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT 17414 { 17415 VULKAN_HPP_ASSERT( 17416 getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR && 17417 "Function <vkGetRayTracingShaderGroupStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" ); 17418 17419 return static_cast<VULKAN_HPP_NAMESPACE::DeviceSize>( 17420 getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR( static_cast<VkDevice>( m_device ), 17421 static_cast<VkPipeline>( m_pipeline ), 17422 group, 17423 static_cast<VkShaderGroupShaderKHR>( groupShader ) ) ); 17424 } 17425 17426 VULKAN_HPP_INLINE void setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize) const17427 CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT 17428 { 17429 VULKAN_HPP_ASSERT( 17430 getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR && 17431 "Function <vkCmdSetRayTracingPipelineStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" ); 17432 17433 getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17434 pipelineStackSize ); 17435 } 17436 17437 //=== VK_EXT_vertex_input_dynamic_state === 17438 setVertexInputEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions) const17439 VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( 17440 ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions, 17441 ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions ) 17442 const VULKAN_HPP_NOEXCEPT 17443 { 17444 VULKAN_HPP_ASSERT( 17445 getDispatcher()->vkCmdSetVertexInputEXT && 17446 "Function <vkCmdSetVertexInputEXT> needs extension <VK_EXT_vertex_input_dynamic_state> enabled!" ); 17447 17448 getDispatcher()->vkCmdSetVertexInputEXT( 17449 static_cast<VkCommandBuffer>( m_commandBuffer ), 17450 vertexBindingDescriptions.size(), 17451 reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ), 17452 vertexAttributeDescriptions.size(), 17453 reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) ); 17454 } 17455 17456 # if defined( VK_USE_PLATFORM_FUCHSIA ) 17457 //=== VK_FUCHSIA_external_memory === 17458 getMemoryZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo) const17459 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t Device::getMemoryZirconHandleFUCHSIA( 17460 const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const 17461 { 17462 VULKAN_HPP_ASSERT( 17463 getDispatcher()->vkGetMemoryZirconHandleFUCHSIA && 17464 "Function <vkGetMemoryZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" ); 17465 17466 zx_handle_t zirconHandle; 17467 VULKAN_HPP_NAMESPACE::Result result = 17468 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA( 17469 static_cast<VkDevice>( m_device ), 17470 reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), 17471 &zirconHandle ) ); 17472 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17473 { 17474 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); 17475 } 17476 return zirconHandle; 17477 } 17478 17479 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA getMemoryZirconHandlePropertiesFUCHSIA(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,zx_handle_t zirconHandle) const17480 Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, 17481 zx_handle_t zirconHandle ) const 17482 { 17483 VULKAN_HPP_ASSERT( 17484 getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA && 17485 "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" ); 17486 17487 VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; 17488 VULKAN_HPP_NAMESPACE::Result result = 17489 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA( 17490 static_cast<VkDevice>( m_device ), 17491 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), 17492 zirconHandle, 17493 reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) ); 17494 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17495 { 17496 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); 17497 } 17498 return memoryZirconHandleProperties; 17499 } 17500 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 17501 17502 # if defined( VK_USE_PLATFORM_FUCHSIA ) 17503 //=== VK_FUCHSIA_external_semaphore === 17504 importSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo) const17505 VULKAN_HPP_INLINE void Device::importSemaphoreZirconHandleFUCHSIA( 17506 const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const 17507 { 17508 VULKAN_HPP_ASSERT( 17509 getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA && 17510 "Function <vkImportSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" ); 17511 17512 VULKAN_HPP_NAMESPACE::Result result = 17513 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA( 17514 static_cast<VkDevice>( m_device ), 17515 reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) ); 17516 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17517 { 17518 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); 17519 } 17520 } 17521 getSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo) const17522 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t Device::getSemaphoreZirconHandleFUCHSIA( 17523 const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const 17524 { 17525 VULKAN_HPP_ASSERT( 17526 getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA && 17527 "Function <vkGetSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" ); 17528 17529 zx_handle_t zirconHandle; 17530 VULKAN_HPP_NAMESPACE::Result result = 17531 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA( 17532 static_cast<VkDevice>( m_device ), 17533 reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), 17534 &zirconHandle ) ); 17535 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17536 { 17537 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); 17538 } 17539 return zirconHandle; 17540 } 17541 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 17542 17543 # if defined( VK_USE_PLATFORM_FUCHSIA ) 17544 //=== VK_FUCHSIA_buffer_collection === 17545 17546 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA createBufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17547 Device::createBufferCollectionFUCHSIA( 17548 VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo, 17549 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17550 { 17551 return VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA( *this, createInfo, allocator ); 17552 } 17553 setImageConstraints(const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo) const17554 VULKAN_HPP_INLINE void BufferCollectionFUCHSIA::setImageConstraints( 17555 const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const 17556 { 17557 VULKAN_HPP_ASSERT( 17558 getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA && 17559 "Function <vkSetBufferCollectionImageConstraintsFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!" ); 17560 17561 VULKAN_HPP_NAMESPACE::Result result = 17562 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA( 17563 static_cast<VkDevice>( m_device ), 17564 static_cast<VkBufferCollectionFUCHSIA>( m_collection ), 17565 reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( &imageConstraintsInfo ) ) ); 17566 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17567 { 17568 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setImageConstraints" ); 17569 } 17570 } 17571 setBufferConstraints(const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo) const17572 VULKAN_HPP_INLINE void BufferCollectionFUCHSIA::setBufferConstraints( 17573 const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const 17574 { 17575 VULKAN_HPP_ASSERT( 17576 getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA && 17577 "Function <vkSetBufferCollectionBufferConstraintsFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!" ); 17578 17579 VULKAN_HPP_NAMESPACE::Result result = 17580 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA( 17581 static_cast<VkDevice>( m_device ), 17582 static_cast<VkBufferCollectionFUCHSIA>( m_collection ), 17583 reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( &bufferConstraintsInfo ) ) ); 17584 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17585 { 17586 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setBufferConstraints" ); 17587 } 17588 } 17589 17590 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties() const17591 BufferCollectionFUCHSIA::getProperties() const 17592 { 17593 VULKAN_HPP_ASSERT( 17594 getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA && 17595 "Function <vkGetBufferCollectionPropertiesFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!" ); 17596 17597 VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties; 17598 VULKAN_HPP_NAMESPACE::Result result = 17599 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA( 17600 static_cast<VkDevice>( m_device ), 17601 static_cast<VkBufferCollectionFUCHSIA>( m_collection ), 17602 reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( &properties ) ) ); 17603 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17604 { 17605 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties" ); 17606 } 17607 return properties; 17608 } 17609 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 17610 17611 //=== VK_HUAWEI_subpass_shading === 17612 17613 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D> getSubpassShadingMaxWorkgroupSizeHUAWEI() const17614 RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const 17615 { 17616 VULKAN_HPP_ASSERT( 17617 getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI && 17618 "Function <vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> needs extension <VK_HUAWEI_subpass_shading> enabled!" ); 17619 17620 VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize; 17621 VULKAN_HPP_NAMESPACE::Result result = 17622 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( 17623 static_cast<VkDevice>( m_device ), 17624 static_cast<VkRenderPass>( m_renderPass ), 17625 reinterpret_cast<VkExtent2D *>( &maxWorkgroupSize ) ) ); 17626 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && 17627 ( result != VULKAN_HPP_NAMESPACE::Result::eIncomplete ) ) 17628 { 17629 throwResultException( result, 17630 VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI" ); 17631 } 17632 return std::make_pair( result, maxWorkgroupSize ); 17633 } 17634 subpassShadingHUAWEI() const17635 VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT 17636 { 17637 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSubpassShadingHUAWEI && 17638 "Function <vkCmdSubpassShadingHUAWEI> needs extension <VK_HUAWEI_subpass_shading> enabled!" ); 17639 17640 getDispatcher()->vkCmdSubpassShadingHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 17641 } 17642 17643 //=== VK_HUAWEI_invocation_mask === 17644 17645 VULKAN_HPP_INLINE void bindInvocationMaskHUAWEI(VULKAN_HPP_NAMESPACE::ImageView imageView,VULKAN_HPP_NAMESPACE::ImageLayout imageLayout) const17646 CommandBuffer::bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, 17647 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT 17648 { 17649 VULKAN_HPP_ASSERT( 17650 getDispatcher()->vkCmdBindInvocationMaskHUAWEI && 17651 "Function <vkCmdBindInvocationMaskHUAWEI> needs extension <VK_HUAWEI_invocation_mask> enabled!" ); 17652 17653 getDispatcher()->vkCmdBindInvocationMaskHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ), 17654 static_cast<VkImageView>( imageView ), 17655 static_cast<VkImageLayout>( imageLayout ) ); 17656 } 17657 17658 //=== VK_NV_external_memory_rdma === 17659 getMemoryRemoteAddressNV(const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo) const17660 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::RemoteAddressNV Device::getMemoryRemoteAddressNV( 17661 const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const 17662 { 17663 VULKAN_HPP_ASSERT( 17664 getDispatcher()->vkGetMemoryRemoteAddressNV && 17665 "Function <vkGetMemoryRemoteAddressNV> needs extension <VK_NV_external_memory_rdma> enabled!" ); 17666 17667 VULKAN_HPP_NAMESPACE::RemoteAddressNV address; 17668 VULKAN_HPP_NAMESPACE::Result result = 17669 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryRemoteAddressNV( 17670 static_cast<VkDevice>( m_device ), 17671 reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ), 17672 reinterpret_cast<VkRemoteAddressNV *>( &address ) ) ); 17673 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17674 { 17675 throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); 17676 } 17677 return address; 17678 } 17679 17680 //=== VK_EXT_extended_dynamic_state2 === 17681 17682 VULKAN_HPP_INLINE void setPatchControlPointsEXT(uint32_t patchControlPoints) const17683 CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT 17684 { 17685 VULKAN_HPP_ASSERT( 17686 getDispatcher()->vkCmdSetPatchControlPointsEXT && 17687 "Function <vkCmdSetPatchControlPointsEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" ); 17688 17689 getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17690 patchControlPoints ); 17691 } 17692 setRasterizerDiscardEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable) const17693 VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( 17694 VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT 17695 { 17696 VULKAN_HPP_ASSERT( 17697 getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT && 17698 "Function <vkCmdSetRasterizerDiscardEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" ); 17699 17700 getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17701 static_cast<VkBool32>( rasterizerDiscardEnable ) ); 17702 } 17703 17704 VULKAN_HPP_INLINE void setDepthBiasEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable) const17705 CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT 17706 { 17707 VULKAN_HPP_ASSERT( 17708 getDispatcher()->vkCmdSetDepthBiasEnableEXT && 17709 "Function <vkCmdSetDepthBiasEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" ); 17710 17711 getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17712 static_cast<VkBool32>( depthBiasEnable ) ); 17713 } 17714 17715 VULKAN_HPP_INLINE void setLogicOpEXT(VULKAN_HPP_NAMESPACE::LogicOp logicOp) const17716 CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT 17717 { 17718 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT && 17719 "Function <vkCmdSetLogicOpEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" ); 17720 17721 getDispatcher()->vkCmdSetLogicOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17722 static_cast<VkLogicOp>( logicOp ) ); 17723 } 17724 setPrimitiveRestartEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable) const17725 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( 17726 VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT 17727 { 17728 VULKAN_HPP_ASSERT( 17729 getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT && 17730 "Function <vkCmdSetPrimitiveRestartEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" ); 17731 17732 getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17733 static_cast<VkBool32>( primitiveRestartEnable ) ); 17734 } 17735 17736 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 17737 //=== VK_QNX_screen_surface === 17738 createScreenSurfaceQNX(VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17739 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR Instance::createScreenSurfaceQNX( 17740 VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, 17741 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17742 { 17743 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator ); 17744 } 17745 17746 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX(uint32_t queueFamilyIndex,struct _screen_window & window) const17747 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, 17748 struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT 17749 { 17750 VULKAN_HPP_ASSERT( 17751 getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX && 17752 "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> needs extension <VK_QNX_screen_surface> enabled!" ); 17753 17754 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( 17755 getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX( 17756 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &window ) ); 17757 } 17758 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 17759 17760 //=== VK_EXT_color_write_enable === 17761 setColorWriteEnableEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables) const17762 VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( 17763 ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT 17764 { 17765 VULKAN_HPP_ASSERT( 17766 getDispatcher()->vkCmdSetColorWriteEnableEXT && 17767 "Function <vkCmdSetColorWriteEnableEXT> needs extension <VK_EXT_color_write_enable> enabled!" ); 17768 17769 getDispatcher()->vkCmdSetColorWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17770 colorWriteEnables.size(), 17771 reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) ); 17772 } 17773 17774 //=== VK_EXT_multi_draw === 17775 17776 VULKAN_HPP_INLINE void drawMultiEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,uint32_t instanceCount,uint32_t firstInstance,uint32_t stride) const17777 CommandBuffer::drawMultiEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo, 17778 uint32_t instanceCount, 17779 uint32_t firstInstance, 17780 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 17781 { 17782 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiEXT && 17783 "Function <vkCmdDrawMultiEXT> needs extension <VK_EXT_multi_draw> enabled!" ); 17784 17785 getDispatcher()->vkCmdDrawMultiEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17786 vertexInfo.size(), 17787 reinterpret_cast<const VkMultiDrawInfoEXT *>( vertexInfo.data() ), 17788 instanceCount, 17789 firstInstance, 17790 stride ); 17791 } 17792 drawMultiIndexedEXT(ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,uint32_t instanceCount,uint32_t firstInstance,uint32_t stride,Optional<const int32_t> vertexOffset) const17793 VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( 17794 ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo, 17795 uint32_t instanceCount, 17796 uint32_t firstInstance, 17797 uint32_t stride, 17798 Optional<const int32_t> vertexOffset ) const VULKAN_HPP_NOEXCEPT 17799 { 17800 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiIndexedEXT && 17801 "Function <vkCmdDrawMultiIndexedEXT> needs extension <VK_EXT_multi_draw> enabled!" ); 17802 17803 getDispatcher()->vkCmdDrawMultiIndexedEXT( 17804 static_cast<VkCommandBuffer>( m_commandBuffer ), 17805 indexInfo.size(), 17806 reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( indexInfo.data() ), 17807 instanceCount, 17808 firstInstance, 17809 stride, 17810 static_cast<const int32_t *>( vertexOffset ) ); 17811 } 17812 17813 //=== VK_EXT_pageable_device_local_memory === 17814 setPriorityEXT(float priority) const17815 VULKAN_HPP_INLINE void DeviceMemory::setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT 17816 { 17817 VULKAN_HPP_ASSERT( 17818 getDispatcher()->vkSetDeviceMemoryPriorityEXT && 17819 "Function <vkSetDeviceMemoryPriorityEXT> needs extension <VK_EXT_pageable_device_local_memory> enabled!" ); 17820 17821 getDispatcher()->vkSetDeviceMemoryPriorityEXT( 17822 static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), priority ); 17823 } 17824 17825 //=== VK_KHR_maintenance4 === 17826 17827 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info) const17828 Device::getBufferMemoryRequirementsKHR( 17829 const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info ) const VULKAN_HPP_NOEXCEPT 17830 { 17831 VULKAN_HPP_ASSERT( 17832 getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && 17833 "Function <vkGetDeviceBufferMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" ); 17834 17835 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 17836 getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( 17837 static_cast<VkDevice>( m_device ), 17838 reinterpret_cast<const VkDeviceBufferMemoryRequirementsKHR *>( &info ), 17839 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 17840 return memoryRequirements; 17841 } 17842 17843 template <typename X, typename Y, typename... Z> getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info) const17844 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getBufferMemoryRequirementsKHR( 17845 const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirementsKHR & info ) const VULKAN_HPP_NOEXCEPT 17846 { 17847 VULKAN_HPP_ASSERT( 17848 getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && 17849 "Function <vkGetDeviceBufferMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" ); 17850 17851 StructureChain<X, Y, Z...> structureChain; 17852 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = 17853 structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 17854 getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( 17855 static_cast<VkDevice>( m_device ), 17856 reinterpret_cast<const VkDeviceBufferMemoryRequirementsKHR *>( &info ), 17857 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 17858 return structureChain; 17859 } 17860 17861 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info) const17862 Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info ) const 17863 VULKAN_HPP_NOEXCEPT 17864 { 17865 VULKAN_HPP_ASSERT( 17866 getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && 17867 "Function <vkGetDeviceImageMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" ); 17868 17869 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 17870 getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( 17871 static_cast<VkDevice>( m_device ), 17872 reinterpret_cast<const VkDeviceImageMemoryRequirementsKHR *>( &info ), 17873 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 17874 return memoryRequirements; 17875 } 17876 17877 template <typename X, typename Y, typename... Z> getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info) const17878 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getImageMemoryRequirementsKHR( 17879 const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info ) const VULKAN_HPP_NOEXCEPT 17880 { 17881 VULKAN_HPP_ASSERT( 17882 getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && 17883 "Function <vkGetDeviceImageMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" ); 17884 17885 StructureChain<X, Y, Z...> structureChain; 17886 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = 17887 structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 17888 getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( 17889 static_cast<VkDevice>( m_device ), 17890 reinterpret_cast<const VkDeviceImageMemoryRequirementsKHR *>( &info ), 17891 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 17892 return structureChain; 17893 } 17894 17895 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info) const17896 Device::getImageSparseMemoryRequirementsKHR( 17897 const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirementsKHR & info ) const VULKAN_HPP_NOEXCEPT 17898 { 17899 VULKAN_HPP_ASSERT( 17900 getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR && 17901 "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" ); 17902 17903 uint32_t sparseMemoryRequirementCount; 17904 getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( 17905 static_cast<VkDevice>( m_device ), 17906 reinterpret_cast<const VkDeviceImageMemoryRequirementsKHR *>( &info ), 17907 &sparseMemoryRequirementCount, 17908 nullptr ); 17909 std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements( 17910 sparseMemoryRequirementCount ); 17911 getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( 17912 static_cast<VkDevice>( m_device ), 17913 reinterpret_cast<const VkDeviceImageMemoryRequirementsKHR *>( &info ), 17914 &sparseMemoryRequirementCount, 17915 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); 17916 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount == sparseMemoryRequirements.size() ); 17917 return sparseMemoryRequirements; 17918 } 17919 17920 #endif 17921 } // namespace VULKAN_HPP_RAII_NAMESPACE 17922 } // namespace VULKAN_HPP_NAMESPACE 17923 #endif 17924