1 // Copyright 2015-2024 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 #if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) ) 13 # include <memory> // std::unique_ptr 14 # include <utility> // std::forward 15 #endif 16 17 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) 18 namespace VULKAN_HPP_NAMESPACE 19 { 20 namespace VULKAN_HPP_RAII_NAMESPACE 21 { 22 template <class T> 23 class CreateReturnType 24 { 25 public: 26 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 27 using Type = VULKAN_HPP_EXPECTED<T, VULKAN_HPP_NAMESPACE::Result>; 28 # else 29 using Type = T; 30 # endif 31 }; 32 33 class ContextDispatcher : public DispatchLoaderBase 34 { 35 public: ContextDispatcher(PFN_vkGetInstanceProcAddr getProcAddr)36 ContextDispatcher( PFN_vkGetInstanceProcAddr getProcAddr ) 37 : vkGetInstanceProcAddr( getProcAddr ) 38 //=== VK_VERSION_1_0 === 39 , vkCreateInstance( PFN_vkCreateInstance( getProcAddr( NULL, "vkCreateInstance" ) ) ) 40 , vkEnumerateInstanceExtensionProperties( PFN_vkEnumerateInstanceExtensionProperties( getProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) ) ) 41 , vkEnumerateInstanceLayerProperties( PFN_vkEnumerateInstanceLayerProperties( getProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) ) ) 42 //=== VK_VERSION_1_1 === 43 , vkEnumerateInstanceVersion( PFN_vkEnumerateInstanceVersion( getProcAddr( NULL, "vkEnumerateInstanceVersion" ) ) ) 44 { 45 } 46 47 public: 48 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; 49 50 //=== VK_VERSION_1_0 === 51 PFN_vkCreateInstance vkCreateInstance = 0; 52 PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; 53 PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; 54 55 //=== VK_VERSION_1_1 === 56 PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; 57 }; 58 59 class InstanceDispatcher : public DispatchLoaderBase 60 { 61 public: InstanceDispatcher(PFN_vkGetInstanceProcAddr getProcAddr,VkInstance instance)62 InstanceDispatcher( PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance ) : vkGetInstanceProcAddr( getProcAddr ) 63 { 64 //=== VK_VERSION_1_0 === 65 vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) ); 66 vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) ); 67 vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) ); 68 vkGetPhysicalDeviceFormatProperties = 69 PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) ); 70 vkGetPhysicalDeviceImageFormatProperties = 71 PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) ); 72 vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) ); 73 vkGetPhysicalDeviceQueueFamilyProperties = 74 PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) ); 75 vkGetPhysicalDeviceMemoryProperties = 76 PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) ); 77 vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) ); 78 vkEnumerateDeviceExtensionProperties = 79 PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) ); 80 vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) ); 81 vkGetPhysicalDeviceSparseImageFormatProperties = 82 PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); 83 84 //=== VK_VERSION_1_1 === 85 vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) ); 86 vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) ); 87 vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) ); 88 vkGetPhysicalDeviceFormatProperties2 = 89 PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) ); 90 vkGetPhysicalDeviceImageFormatProperties2 = 91 PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) ); 92 vkGetPhysicalDeviceQueueFamilyProperties2 = 93 PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); 94 vkGetPhysicalDeviceMemoryProperties2 = 95 PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) ); 96 vkGetPhysicalDeviceSparseImageFormatProperties2 = 97 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) ); 98 vkGetPhysicalDeviceExternalBufferProperties = 99 PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) ); 100 vkGetPhysicalDeviceExternalFenceProperties = 101 PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) ); 102 vkGetPhysicalDeviceExternalSemaphoreProperties = 103 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) ); 104 105 //=== VK_VERSION_1_3 === 106 vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) ); 107 108 //=== VK_KHR_surface === 109 vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) ); 110 vkGetPhysicalDeviceSurfaceSupportKHR = 111 PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); 112 vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 113 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); 114 vkGetPhysicalDeviceSurfaceFormatsKHR = 115 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); 116 vkGetPhysicalDeviceSurfacePresentModesKHR = 117 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); 118 119 //=== VK_KHR_swapchain === 120 vkGetPhysicalDevicePresentRectanglesKHR = 121 PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) ); 122 123 //=== VK_KHR_display === 124 vkGetPhysicalDeviceDisplayPropertiesKHR = 125 PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) ); 126 vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 127 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) ); 128 vkGetDisplayPlaneSupportedDisplaysKHR = 129 PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) ); 130 vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) ); 131 vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) ); 132 vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) ); 133 vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) ); 134 135 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 136 //=== VK_KHR_xlib_surface === 137 vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) ); 138 vkGetPhysicalDeviceXlibPresentationSupportKHR = 139 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) ); 140 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 141 142 # if defined( VK_USE_PLATFORM_XCB_KHR ) 143 //=== VK_KHR_xcb_surface === 144 vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) ); 145 vkGetPhysicalDeviceXcbPresentationSupportKHR = 146 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) ); 147 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 148 149 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 150 //=== VK_KHR_wayland_surface === 151 vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) ); 152 vkGetPhysicalDeviceWaylandPresentationSupportKHR = 153 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) ); 154 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 155 156 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 157 //=== VK_KHR_android_surface === 158 vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) ); 159 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 160 161 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 162 //=== VK_KHR_win32_surface === 163 vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) ); 164 vkGetPhysicalDeviceWin32PresentationSupportKHR = 165 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) ); 166 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 167 168 //=== VK_EXT_debug_report === 169 vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) ); 170 vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) ); 171 vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) ); 172 173 //=== VK_KHR_video_queue === 174 vkGetPhysicalDeviceVideoCapabilitiesKHR = 175 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) ); 176 vkGetPhysicalDeviceVideoFormatPropertiesKHR = 177 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) ); 178 179 # if defined( VK_USE_PLATFORM_GGP ) 180 //=== VK_GGP_stream_descriptor_surface === 181 vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); 182 # endif /*VK_USE_PLATFORM_GGP*/ 183 184 //=== VK_NV_external_memory_capabilities === 185 vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 186 PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) ); 187 188 //=== VK_KHR_get_physical_device_properties2 === 189 vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) ); 190 if ( !vkGetPhysicalDeviceFeatures2 ) 191 vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR; 192 vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) ); 193 if ( !vkGetPhysicalDeviceProperties2 ) 194 vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR; 195 vkGetPhysicalDeviceFormatProperties2KHR = 196 PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) ); 197 if ( !vkGetPhysicalDeviceFormatProperties2 ) 198 vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR; 199 vkGetPhysicalDeviceImageFormatProperties2KHR = 200 PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) ); 201 if ( !vkGetPhysicalDeviceImageFormatProperties2 ) 202 vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR; 203 vkGetPhysicalDeviceQueueFamilyProperties2KHR = 204 PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) ); 205 if ( !vkGetPhysicalDeviceQueueFamilyProperties2 ) 206 vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; 207 vkGetPhysicalDeviceMemoryProperties2KHR = 208 PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) ); 209 if ( !vkGetPhysicalDeviceMemoryProperties2 ) 210 vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR; 211 vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 212 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) ); 213 if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 ) 214 vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR; 215 216 # if defined( VK_USE_PLATFORM_VI_NN ) 217 //=== VK_NN_vi_surface === 218 vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); 219 # endif /*VK_USE_PLATFORM_VI_NN*/ 220 221 //=== VK_KHR_device_group_creation === 222 vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) ); 223 if ( !vkEnumeratePhysicalDeviceGroups ) 224 vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR; 225 226 //=== VK_KHR_external_memory_capabilities === 227 vkGetPhysicalDeviceExternalBufferPropertiesKHR = 228 PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) ); 229 if ( !vkGetPhysicalDeviceExternalBufferProperties ) 230 vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR; 231 232 //=== VK_KHR_external_semaphore_capabilities === 233 vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 234 PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) ); 235 if ( !vkGetPhysicalDeviceExternalSemaphoreProperties ) 236 vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; 237 238 //=== VK_EXT_direct_mode_display === 239 vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); 240 241 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 242 //=== VK_EXT_acquire_xlib_display === 243 vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); 244 vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); 245 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 246 247 //=== VK_EXT_display_surface_counter === 248 vkGetPhysicalDeviceSurfaceCapabilities2EXT = 249 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) ); 250 251 //=== VK_KHR_external_fence_capabilities === 252 vkGetPhysicalDeviceExternalFencePropertiesKHR = 253 PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) ); 254 if ( !vkGetPhysicalDeviceExternalFenceProperties ) 255 vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR; 256 257 //=== VK_KHR_performance_query === 258 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 259 vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) ); 260 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( 261 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) ); 262 263 //=== VK_KHR_get_surface_capabilities2 === 264 vkGetPhysicalDeviceSurfaceCapabilities2KHR = 265 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) ); 266 vkGetPhysicalDeviceSurfaceFormats2KHR = 267 PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); 268 269 //=== VK_KHR_get_display_properties2 === 270 vkGetPhysicalDeviceDisplayProperties2KHR = 271 PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) ); 272 vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 273 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) ); 274 vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) ); 275 vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) ); 276 277 # if defined( VK_USE_PLATFORM_IOS_MVK ) 278 //=== VK_MVK_ios_surface === 279 vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) ); 280 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 281 282 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 283 //=== VK_MVK_macos_surface === 284 vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) ); 285 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 286 287 //=== VK_EXT_debug_utils === 288 vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) ); 289 vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) ); 290 vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) ); 291 292 //=== VK_EXT_sample_locations === 293 vkGetPhysicalDeviceMultisamplePropertiesEXT = 294 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) ); 295 296 //=== VK_EXT_calibrated_timestamps === 297 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 298 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) ); 299 if ( !vkGetPhysicalDeviceCalibrateableTimeDomainsKHR ) 300 vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; 301 302 # if defined( VK_USE_PLATFORM_FUCHSIA ) 303 //=== VK_FUCHSIA_imagepipe_surface === 304 vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) ); 305 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 306 307 # if defined( VK_USE_PLATFORM_METAL_EXT ) 308 //=== VK_EXT_metal_surface === 309 vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); 310 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 311 312 //=== VK_KHR_fragment_shading_rate === 313 vkGetPhysicalDeviceFragmentShadingRatesKHR = 314 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) ); 315 316 //=== VK_EXT_tooling_info === 317 vkGetPhysicalDeviceToolPropertiesEXT = 318 PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) ); 319 if ( !vkGetPhysicalDeviceToolProperties ) 320 vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT; 321 322 //=== VK_NV_cooperative_matrix === 323 vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 324 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) ); 325 326 //=== VK_NV_coverage_reduction_mode === 327 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 328 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) ); 329 330 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 331 //=== VK_EXT_full_screen_exclusive === 332 vkGetPhysicalDeviceSurfacePresentModes2EXT = 333 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) ); 334 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 335 336 //=== VK_EXT_headless_surface === 337 vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) ); 338 339 //=== VK_EXT_acquire_drm_display === 340 vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) ); 341 vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) ); 342 343 //=== VK_KHR_video_encode_queue === 344 vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( 345 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) ); 346 347 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 348 //=== VK_NV_acquire_winrt_display === 349 vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); 350 vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) ); 351 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 352 353 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 354 //=== VK_EXT_directfb_surface === 355 vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) ); 356 vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 357 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) ); 358 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 359 360 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 361 //=== VK_QNX_screen_surface === 362 vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) ); 363 vkGetPhysicalDeviceScreenPresentationSupportQNX = 364 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) ); 365 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 366 367 //=== VK_NV_optical_flow === 368 vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 369 PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) ); 370 371 //=== VK_KHR_cooperative_matrix === 372 vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 373 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR" ) ); 374 375 //=== VK_KHR_calibrated_timestamps === 376 vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 377 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) ); 378 379 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) ); 380 } 381 382 public: 383 //=== VK_VERSION_1_0 === 384 PFN_vkDestroyInstance vkDestroyInstance = 0; 385 PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; 386 PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; 387 PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; 388 PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; 389 PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; 390 PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; 391 PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; 392 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; 393 PFN_vkCreateDevice vkCreateDevice = 0; 394 PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; 395 PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; 396 PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; 397 398 //=== VK_VERSION_1_1 === 399 PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; 400 PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; 401 PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; 402 PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; 403 PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; 404 PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; 405 PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; 406 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; 407 PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; 408 PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; 409 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; 410 411 //=== VK_VERSION_1_3 === 412 PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0; 413 414 //=== VK_KHR_surface === 415 PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; 416 PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; 417 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; 418 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; 419 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; 420 421 //=== VK_KHR_swapchain === 422 PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; 423 424 //=== VK_KHR_display === 425 PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; 426 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; 427 PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; 428 PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; 429 PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; 430 PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; 431 PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; 432 433 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 434 //=== VK_KHR_xlib_surface === 435 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; 436 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; 437 # else 438 PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; 439 PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; 440 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 441 442 # if defined( VK_USE_PLATFORM_XCB_KHR ) 443 //=== VK_KHR_xcb_surface === 444 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; 445 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; 446 # else 447 PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; 448 PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; 449 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 450 451 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 452 //=== VK_KHR_wayland_surface === 453 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; 454 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; 455 # else 456 PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; 457 PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; 458 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 459 460 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 461 //=== VK_KHR_android_surface === 462 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; 463 # else 464 PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; 465 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 466 467 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 468 //=== VK_KHR_win32_surface === 469 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; 470 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; 471 # else 472 PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; 473 PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; 474 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 475 476 //=== VK_EXT_debug_report === 477 PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; 478 PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; 479 PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; 480 481 //=== VK_KHR_video_queue === 482 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0; 483 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0; 484 485 # if defined( VK_USE_PLATFORM_GGP ) 486 //=== VK_GGP_stream_descriptor_surface === 487 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; 488 # else 489 PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; 490 # endif /*VK_USE_PLATFORM_GGP*/ 491 492 //=== VK_NV_external_memory_capabilities === 493 PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; 494 495 //=== VK_KHR_get_physical_device_properties2 === 496 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; 497 PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; 498 PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; 499 PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; 500 PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; 501 PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; 502 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; 503 504 # if defined( VK_USE_PLATFORM_VI_NN ) 505 //=== VK_NN_vi_surface === 506 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; 507 # else 508 PFN_dummy vkCreateViSurfaceNN_placeholder = 0; 509 # endif /*VK_USE_PLATFORM_VI_NN*/ 510 511 //=== VK_KHR_device_group_creation === 512 PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; 513 514 //=== VK_KHR_external_memory_capabilities === 515 PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; 516 517 //=== VK_KHR_external_semaphore_capabilities === 518 PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; 519 520 //=== VK_EXT_direct_mode_display === 521 PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; 522 523 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 524 //=== VK_EXT_acquire_xlib_display === 525 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; 526 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; 527 # else 528 PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; 529 PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; 530 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 531 532 //=== VK_EXT_display_surface_counter === 533 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; 534 535 //=== VK_KHR_external_fence_capabilities === 536 PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; 537 538 //=== VK_KHR_performance_query === 539 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; 540 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; 541 542 //=== VK_KHR_get_surface_capabilities2 === 543 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; 544 PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; 545 546 //=== VK_KHR_get_display_properties2 === 547 PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; 548 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; 549 PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; 550 PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; 551 552 # if defined( VK_USE_PLATFORM_IOS_MVK ) 553 //=== VK_MVK_ios_surface === 554 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; 555 # else 556 PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; 557 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 558 559 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 560 //=== VK_MVK_macos_surface === 561 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; 562 # else 563 PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; 564 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 565 566 //=== VK_EXT_debug_utils === 567 PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; 568 PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; 569 PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; 570 571 //=== VK_EXT_sample_locations === 572 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; 573 574 //=== VK_EXT_calibrated_timestamps === 575 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; 576 577 # if defined( VK_USE_PLATFORM_FUCHSIA ) 578 //=== VK_FUCHSIA_imagepipe_surface === 579 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; 580 # else 581 PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; 582 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 583 584 # if defined( VK_USE_PLATFORM_METAL_EXT ) 585 //=== VK_EXT_metal_surface === 586 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; 587 # else 588 PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; 589 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 590 591 //=== VK_KHR_fragment_shading_rate === 592 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0; 593 594 //=== VK_EXT_tooling_info === 595 PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0; 596 597 //=== VK_NV_cooperative_matrix === 598 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0; 599 600 //=== VK_NV_coverage_reduction_mode === 601 PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; 602 603 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 604 //=== VK_EXT_full_screen_exclusive === 605 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; 606 # else 607 PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; 608 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 609 610 //=== VK_EXT_headless_surface === 611 PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; 612 613 //=== VK_EXT_acquire_drm_display === 614 PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; 615 PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; 616 617 //=== VK_KHR_video_encode_queue === 618 PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0; 619 620 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 621 //=== VK_NV_acquire_winrt_display === 622 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; 623 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; 624 # else 625 PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; 626 PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; 627 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 628 629 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 630 //=== VK_EXT_directfb_surface === 631 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; 632 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; 633 # else 634 PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; 635 PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; 636 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 637 638 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 639 //=== VK_QNX_screen_surface === 640 PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; 641 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; 642 # else 643 PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; 644 PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; 645 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 646 647 //=== VK_NV_optical_flow === 648 PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 0; 649 650 //=== VK_KHR_cooperative_matrix === 651 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 0; 652 653 //=== VK_KHR_calibrated_timestamps === 654 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0; 655 656 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; 657 }; 658 659 class DeviceDispatcher : public DispatchLoaderBase 660 { 661 public: DeviceDispatcher(PFN_vkGetDeviceProcAddr getProcAddr,VkDevice device)662 DeviceDispatcher( PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device ) : vkGetDeviceProcAddr( getProcAddr ) 663 { 664 //=== VK_VERSION_1_0 === 665 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) ); 666 vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) ); 667 vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) ); 668 vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) ); 669 vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) ); 670 vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) ); 671 vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) ); 672 vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) ); 673 vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) ); 674 vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) ); 675 vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) ); 676 vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) ); 677 vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) ); 678 vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) ); 679 vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) ); 680 vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) ); 681 vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) ); 682 vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) ); 683 vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) ); 684 vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) ); 685 vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) ); 686 vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) ); 687 vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) ); 688 vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) ); 689 vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) ); 690 vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) ); 691 vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) ); 692 vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) ); 693 vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) ); 694 vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) ); 695 vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) ); 696 vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) ); 697 vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) ); 698 vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) ); 699 vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) ); 700 vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) ); 701 vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) ); 702 vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) ); 703 vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) ); 704 vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) ); 705 vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) ); 706 vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) ); 707 vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) ); 708 vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) ); 709 vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) ); 710 vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) ); 711 vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) ); 712 vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) ); 713 vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) ); 714 vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) ); 715 vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) ); 716 vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) ); 717 vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) ); 718 vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) ); 719 vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) ); 720 vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) ); 721 vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) ); 722 vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) ); 723 vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) ); 724 vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) ); 725 vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) ); 726 vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) ); 727 vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) ); 728 vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) ); 729 vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) ); 730 vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) ); 731 vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) ); 732 vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) ); 733 vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) ); 734 vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) ); 735 vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) ); 736 vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) ); 737 vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) ); 738 vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) ); 739 vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) ); 740 vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) ); 741 vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) ); 742 vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) ); 743 vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) ); 744 vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) ); 745 vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) ); 746 vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) ); 747 vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) ); 748 vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) ); 749 vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) ); 750 vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) ); 751 vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) ); 752 vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) ); 753 vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) ); 754 vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) ); 755 vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) ); 756 vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) ); 757 vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) ); 758 vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) ); 759 vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) ); 760 vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) ); 761 vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) ); 762 vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) ); 763 vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) ); 764 vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) ); 765 vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) ); 766 vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) ); 767 vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) ); 768 vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) ); 769 vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) ); 770 vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) ); 771 vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) ); 772 vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) ); 773 vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) ); 774 vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) ); 775 vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) ); 776 vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) ); 777 vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) ); 778 vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) ); 779 vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) ); 780 vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) ); 781 vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) ); 782 vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) ); 783 vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) ); 784 vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) ); 785 vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) ); 786 787 //=== VK_VERSION_1_1 === 788 vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) ); 789 vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) ); 790 vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) ); 791 vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) ); 792 vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) ); 793 vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) ); 794 vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) ); 795 vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) ); 796 vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) ); 797 vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) ); 798 vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) ); 799 vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) ); 800 vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) ); 801 vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) ); 802 vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) ); 803 vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) ); 804 805 //=== VK_VERSION_1_2 === 806 vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) ); 807 vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) ); 808 vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) ); 809 vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) ); 810 vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) ); 811 vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) ); 812 vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) ); 813 vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) ); 814 vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) ); 815 vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) ); 816 vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) ); 817 vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) ); 818 vkGetDeviceMemoryOpaqueCaptureAddress = 819 PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); 820 821 //=== VK_VERSION_1_3 === 822 vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) ); 823 vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) ); 824 vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) ); 825 vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) ); 826 vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) ); 827 vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) ); 828 vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) ); 829 vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) ); 830 vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) ); 831 vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) ); 832 vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) ); 833 vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) ); 834 vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) ); 835 vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) ); 836 vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) ); 837 vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) ); 838 vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) ); 839 vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) ); 840 vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) ); 841 vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) ); 842 vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) ); 843 vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) ); 844 vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) ); 845 vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) ); 846 vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) ); 847 vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) ); 848 vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) ); 849 vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) ); 850 vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) ); 851 vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) ); 852 vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) ); 853 vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) ); 854 vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) ); 855 vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) ); 856 vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) ); 857 vkGetDeviceImageSparseMemoryRequirements = 858 PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) ); 859 860 //=== VK_VERSION_1_4 === 861 vkCmdSetLineStipple = PFN_vkCmdSetLineStipple( vkGetDeviceProcAddr( device, "vkCmdSetLineStipple" ) ); 862 vkMapMemory2 = PFN_vkMapMemory2( vkGetDeviceProcAddr( device, "vkMapMemory2" ) ); 863 vkUnmapMemory2 = PFN_vkUnmapMemory2( vkGetDeviceProcAddr( device, "vkUnmapMemory2" ) ); 864 vkCmdBindIndexBuffer2 = PFN_vkCmdBindIndexBuffer2( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2" ) ); 865 vkGetRenderingAreaGranularity = PFN_vkGetRenderingAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularity" ) ); 866 vkGetDeviceImageSubresourceLayout = PFN_vkGetDeviceImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayout" ) ); 867 vkGetImageSubresourceLayout2 = PFN_vkGetImageSubresourceLayout2( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2" ) ); 868 vkCmdPushDescriptorSet = PFN_vkCmdPushDescriptorSet( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet" ) ); 869 vkCmdPushDescriptorSetWithTemplate = PFN_vkCmdPushDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate" ) ); 870 vkCmdSetRenderingAttachmentLocations = 871 PFN_vkCmdSetRenderingAttachmentLocations( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocations" ) ); 872 vkCmdSetRenderingInputAttachmentIndices = 873 PFN_vkCmdSetRenderingInputAttachmentIndices( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndices" ) ); 874 vkCmdBindDescriptorSets2 = PFN_vkCmdBindDescriptorSets2( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2" ) ); 875 vkCmdPushConstants2 = PFN_vkCmdPushConstants2( vkGetDeviceProcAddr( device, "vkCmdPushConstants2" ) ); 876 vkCmdPushDescriptorSet2 = PFN_vkCmdPushDescriptorSet2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2" ) ); 877 vkCmdPushDescriptorSetWithTemplate2 = PFN_vkCmdPushDescriptorSetWithTemplate2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2" ) ); 878 vkCopyMemoryToImage = PFN_vkCopyMemoryToImage( vkGetDeviceProcAddr( device, "vkCopyMemoryToImage" ) ); 879 vkCopyImageToMemory = PFN_vkCopyImageToMemory( vkGetDeviceProcAddr( device, "vkCopyImageToMemory" ) ); 880 vkCopyImageToImage = PFN_vkCopyImageToImage( vkGetDeviceProcAddr( device, "vkCopyImageToImage" ) ); 881 vkTransitionImageLayout = PFN_vkTransitionImageLayout( vkGetDeviceProcAddr( device, "vkTransitionImageLayout" ) ); 882 883 //=== VK_KHR_swapchain === 884 vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) ); 885 vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) ); 886 vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) ); 887 vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) ); 888 vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) ); 889 vkGetDeviceGroupPresentCapabilitiesKHR = 890 PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); 891 vkGetDeviceGroupSurfacePresentModesKHR = 892 PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); 893 vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) ); 894 895 //=== VK_KHR_display_swapchain === 896 vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) ); 897 898 //=== VK_EXT_debug_marker === 899 vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) ); 900 vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) ); 901 vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) ); 902 vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) ); 903 vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) ); 904 905 //=== VK_KHR_video_queue === 906 vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) ); 907 vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) ); 908 vkGetVideoSessionMemoryRequirementsKHR = 909 PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) ); 910 vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) ); 911 vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) ); 912 vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) ); 913 vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) ); 914 vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) ); 915 vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) ); 916 vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) ); 917 918 //=== VK_KHR_video_decode_queue === 919 vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) ); 920 921 //=== VK_EXT_transform_feedback === 922 vkCmdBindTransformFeedbackBuffersEXT = 923 PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) ); 924 vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) ); 925 vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) ); 926 vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) ); 927 vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) ); 928 vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) ); 929 930 //=== VK_NVX_binary_import === 931 vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) ); 932 vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) ); 933 vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) ); 934 vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) ); 935 vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) ); 936 937 //=== VK_NVX_image_view_handle === 938 vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) ); 939 vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) ); 940 941 //=== VK_AMD_draw_indirect_count === 942 vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) ); 943 if ( !vkCmdDrawIndirectCount ) 944 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; 945 vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) ); 946 if ( !vkCmdDrawIndexedIndirectCount ) 947 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; 948 949 //=== VK_AMD_shader_info === 950 vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) ); 951 952 //=== VK_KHR_dynamic_rendering === 953 vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) ); 954 if ( !vkCmdBeginRendering ) 955 vkCmdBeginRendering = vkCmdBeginRenderingKHR; 956 vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) ); 957 if ( !vkCmdEndRendering ) 958 vkCmdEndRendering = vkCmdEndRenderingKHR; 959 960 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 961 //=== VK_NV_external_memory_win32 === 962 vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) ); 963 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 964 965 //=== VK_KHR_device_group === 966 vkGetDeviceGroupPeerMemoryFeaturesKHR = 967 PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); 968 if ( !vkGetDeviceGroupPeerMemoryFeatures ) 969 vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; 970 vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) ); 971 if ( !vkCmdSetDeviceMask ) 972 vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; 973 vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) ); 974 if ( !vkCmdDispatchBase ) 975 vkCmdDispatchBase = vkCmdDispatchBaseKHR; 976 977 //=== VK_KHR_maintenance1 === 978 vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) ); 979 if ( !vkTrimCommandPool ) 980 vkTrimCommandPool = vkTrimCommandPoolKHR; 981 982 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 983 //=== VK_KHR_external_memory_win32 === 984 vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) ); 985 vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) ); 986 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 987 988 //=== VK_KHR_external_memory_fd === 989 vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) ); 990 vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) ); 991 992 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 993 //=== VK_KHR_external_semaphore_win32 === 994 vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) ); 995 vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) ); 996 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 997 998 //=== VK_KHR_external_semaphore_fd === 999 vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) ); 1000 vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) ); 1001 1002 //=== VK_KHR_push_descriptor === 1003 vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) ); 1004 if ( !vkCmdPushDescriptorSet ) 1005 vkCmdPushDescriptorSet = vkCmdPushDescriptorSetKHR; 1006 vkCmdPushDescriptorSetWithTemplateKHR = 1007 PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); 1008 if ( !vkCmdPushDescriptorSetWithTemplate ) 1009 vkCmdPushDescriptorSetWithTemplate = vkCmdPushDescriptorSetWithTemplateKHR; 1010 1011 //=== VK_EXT_conditional_rendering === 1012 vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) ); 1013 vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) ); 1014 1015 //=== VK_KHR_descriptor_update_template === 1016 vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) ); 1017 if ( !vkCreateDescriptorUpdateTemplate ) 1018 vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; 1019 vkDestroyDescriptorUpdateTemplateKHR = 1020 PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) ); 1021 if ( !vkDestroyDescriptorUpdateTemplate ) 1022 vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; 1023 vkUpdateDescriptorSetWithTemplateKHR = 1024 PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) ); 1025 if ( !vkUpdateDescriptorSetWithTemplate ) 1026 vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; 1027 1028 //=== VK_NV_clip_space_w_scaling === 1029 vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) ); 1030 1031 //=== VK_EXT_display_control === 1032 vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) ); 1033 vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) ); 1034 vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) ); 1035 vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) ); 1036 1037 //=== VK_GOOGLE_display_timing === 1038 vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) ); 1039 vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) ); 1040 1041 //=== VK_EXT_discard_rectangles === 1042 vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) ); 1043 vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) ); 1044 vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) ); 1045 1046 //=== VK_EXT_hdr_metadata === 1047 vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) ); 1048 1049 //=== VK_KHR_create_renderpass2 === 1050 vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) ); 1051 if ( !vkCreateRenderPass2 ) 1052 vkCreateRenderPass2 = vkCreateRenderPass2KHR; 1053 vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) ); 1054 if ( !vkCmdBeginRenderPass2 ) 1055 vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; 1056 vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) ); 1057 if ( !vkCmdNextSubpass2 ) 1058 vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; 1059 vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) ); 1060 if ( !vkCmdEndRenderPass2 ) 1061 vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; 1062 1063 //=== VK_KHR_shared_presentable_image === 1064 vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) ); 1065 1066 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 1067 //=== VK_KHR_external_fence_win32 === 1068 vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) ); 1069 vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) ); 1070 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 1071 1072 //=== VK_KHR_external_fence_fd === 1073 vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) ); 1074 vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) ); 1075 1076 //=== VK_KHR_performance_query === 1077 vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) ); 1078 vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) ); 1079 1080 //=== VK_EXT_debug_utils === 1081 vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) ); 1082 vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) ); 1083 vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) ); 1084 vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) ); 1085 vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) ); 1086 vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) ); 1087 vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) ); 1088 vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) ); 1089 1090 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 1091 //=== VK_ANDROID_external_memory_android_hardware_buffer === 1092 vkGetAndroidHardwareBufferPropertiesANDROID = 1093 PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); 1094 vkGetMemoryAndroidHardwareBufferANDROID = 1095 PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); 1096 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 1097 1098 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 1099 //=== VK_AMDX_shader_enqueue === 1100 vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) ); 1101 vkGetExecutionGraphPipelineScratchSizeAMDX = 1102 PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) ); 1103 vkGetExecutionGraphPipelineNodeIndexAMDX = 1104 PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) ); 1105 vkCmdInitializeGraphScratchMemoryAMDX = 1106 PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetDeviceProcAddr( device, "vkCmdInitializeGraphScratchMemoryAMDX" ) ); 1107 vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphAMDX" ) ); 1108 vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectAMDX" ) ); 1109 vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) ); 1110 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 1111 1112 //=== VK_EXT_sample_locations === 1113 vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) ); 1114 1115 //=== VK_KHR_get_memory_requirements2 === 1116 vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) ); 1117 if ( !vkGetImageMemoryRequirements2 ) 1118 vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; 1119 vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) ); 1120 if ( !vkGetBufferMemoryRequirements2 ) 1121 vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; 1122 vkGetImageSparseMemoryRequirements2KHR = 1123 PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) ); 1124 if ( !vkGetImageSparseMemoryRequirements2 ) 1125 vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; 1126 1127 //=== VK_KHR_acceleration_structure === 1128 vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) ); 1129 vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) ); 1130 vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) ); 1131 vkCmdBuildAccelerationStructuresIndirectKHR = 1132 PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); 1133 vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) ); 1134 vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) ); 1135 vkCopyAccelerationStructureToMemoryKHR = 1136 PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) ); 1137 vkCopyMemoryToAccelerationStructureKHR = 1138 PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) ); 1139 vkWriteAccelerationStructuresPropertiesKHR = 1140 PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) ); 1141 vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) ); 1142 vkCmdCopyAccelerationStructureToMemoryKHR = 1143 PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); 1144 vkCmdCopyMemoryToAccelerationStructureKHR = 1145 PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); 1146 vkGetAccelerationStructureDeviceAddressKHR = 1147 PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) ); 1148 vkCmdWriteAccelerationStructuresPropertiesKHR = 1149 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); 1150 vkGetDeviceAccelerationStructureCompatibilityKHR = 1151 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); 1152 vkGetAccelerationStructureBuildSizesKHR = 1153 PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) ); 1154 1155 //=== VK_KHR_ray_tracing_pipeline === 1156 vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) ); 1157 vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) ); 1158 vkGetRayTracingShaderGroupHandlesKHR = 1159 PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) ); 1160 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 1161 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); 1162 vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) ); 1163 vkGetRayTracingShaderGroupStackSizeKHR = 1164 PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); 1165 vkCmdSetRayTracingPipelineStackSizeKHR = 1166 PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); 1167 1168 //=== VK_KHR_sampler_ycbcr_conversion === 1169 vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) ); 1170 if ( !vkCreateSamplerYcbcrConversion ) 1171 vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; 1172 vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) ); 1173 if ( !vkDestroySamplerYcbcrConversion ) 1174 vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; 1175 1176 //=== VK_KHR_bind_memory2 === 1177 vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) ); 1178 if ( !vkBindBufferMemory2 ) 1179 vkBindBufferMemory2 = vkBindBufferMemory2KHR; 1180 vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) ); 1181 if ( !vkBindImageMemory2 ) 1182 vkBindImageMemory2 = vkBindImageMemory2KHR; 1183 1184 //=== VK_EXT_image_drm_format_modifier === 1185 vkGetImageDrmFormatModifierPropertiesEXT = 1186 PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); 1187 1188 //=== VK_EXT_validation_cache === 1189 vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) ); 1190 vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) ); 1191 vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) ); 1192 vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) ); 1193 1194 //=== VK_NV_shading_rate_image === 1195 vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) ); 1196 vkCmdSetViewportShadingRatePaletteNV = 1197 PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) ); 1198 vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) ); 1199 1200 //=== VK_NV_ray_tracing === 1201 vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) ); 1202 vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) ); 1203 vkGetAccelerationStructureMemoryRequirementsNV = 1204 PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); 1205 vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) ); 1206 vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) ); 1207 vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) ); 1208 vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) ); 1209 vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) ); 1210 vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) ); 1211 if ( !vkGetRayTracingShaderGroupHandlesKHR ) 1212 vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; 1213 vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) ); 1214 vkCmdWriteAccelerationStructuresPropertiesNV = 1215 PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); 1216 vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) ); 1217 1218 //=== VK_KHR_maintenance3 === 1219 vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) ); 1220 if ( !vkGetDescriptorSetLayoutSupport ) 1221 vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; 1222 1223 //=== VK_KHR_draw_indirect_count === 1224 vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) ); 1225 if ( !vkCmdDrawIndirectCount ) 1226 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; 1227 vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) ); 1228 if ( !vkCmdDrawIndexedIndirectCount ) 1229 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; 1230 1231 //=== VK_EXT_external_memory_host === 1232 vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) ); 1233 1234 //=== VK_AMD_buffer_marker === 1235 vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) ); 1236 1237 //=== VK_EXT_calibrated_timestamps === 1238 vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) ); 1239 if ( !vkGetCalibratedTimestampsKHR ) 1240 vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT; 1241 1242 //=== VK_NV_mesh_shader === 1243 vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) ); 1244 vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) ); 1245 vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) ); 1246 1247 //=== VK_NV_scissor_exclusive === 1248 vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) ); 1249 vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) ); 1250 1251 //=== VK_NV_device_diagnostic_checkpoints === 1252 vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) ); 1253 vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) ); 1254 1255 //=== VK_KHR_timeline_semaphore === 1256 vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) ); 1257 if ( !vkGetSemaphoreCounterValue ) 1258 vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; 1259 vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) ); 1260 if ( !vkWaitSemaphores ) 1261 vkWaitSemaphores = vkWaitSemaphoresKHR; 1262 vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) ); 1263 if ( !vkSignalSemaphore ) 1264 vkSignalSemaphore = vkSignalSemaphoreKHR; 1265 1266 //=== VK_INTEL_performance_query === 1267 vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) ); 1268 vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) ); 1269 vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) ); 1270 vkCmdSetPerformanceStreamMarkerINTEL = 1271 PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); 1272 vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) ); 1273 vkAcquirePerformanceConfigurationINTEL = 1274 PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) ); 1275 vkReleasePerformanceConfigurationINTEL = 1276 PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) ); 1277 vkQueueSetPerformanceConfigurationINTEL = 1278 PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) ); 1279 vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) ); 1280 1281 //=== VK_AMD_display_native_hdr === 1282 vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) ); 1283 1284 //=== VK_KHR_fragment_shading_rate === 1285 vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) ); 1286 1287 //=== VK_KHR_dynamic_rendering_local_read === 1288 vkCmdSetRenderingAttachmentLocationsKHR = 1289 PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocationsKHR" ) ); 1290 if ( !vkCmdSetRenderingAttachmentLocations ) 1291 vkCmdSetRenderingAttachmentLocations = vkCmdSetRenderingAttachmentLocationsKHR; 1292 vkCmdSetRenderingInputAttachmentIndicesKHR = 1293 PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) ); 1294 if ( !vkCmdSetRenderingInputAttachmentIndices ) 1295 vkCmdSetRenderingInputAttachmentIndices = vkCmdSetRenderingInputAttachmentIndicesKHR; 1296 1297 //=== VK_EXT_buffer_device_address === 1298 vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) ); 1299 if ( !vkGetBufferDeviceAddress ) 1300 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; 1301 1302 //=== VK_KHR_present_wait === 1303 vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) ); 1304 1305 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 1306 //=== VK_EXT_full_screen_exclusive === 1307 vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) ); 1308 vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) ); 1309 vkGetDeviceGroupSurfacePresentModes2EXT = 1310 PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); 1311 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 1312 1313 //=== VK_KHR_buffer_device_address === 1314 vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) ); 1315 if ( !vkGetBufferDeviceAddress ) 1316 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; 1317 vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) ); 1318 if ( !vkGetBufferOpaqueCaptureAddress ) 1319 vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; 1320 vkGetDeviceMemoryOpaqueCaptureAddressKHR = 1321 PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); 1322 if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) 1323 vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; 1324 1325 //=== VK_EXT_line_rasterization === 1326 vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) ); 1327 if ( !vkCmdSetLineStipple ) 1328 vkCmdSetLineStipple = vkCmdSetLineStippleEXT; 1329 1330 //=== VK_EXT_host_query_reset === 1331 vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) ); 1332 if ( !vkResetQueryPool ) 1333 vkResetQueryPool = vkResetQueryPoolEXT; 1334 1335 //=== VK_EXT_extended_dynamic_state === 1336 vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) ); 1337 if ( !vkCmdSetCullMode ) 1338 vkCmdSetCullMode = vkCmdSetCullModeEXT; 1339 vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) ); 1340 if ( !vkCmdSetFrontFace ) 1341 vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; 1342 vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) ); 1343 if ( !vkCmdSetPrimitiveTopology ) 1344 vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; 1345 vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) ); 1346 if ( !vkCmdSetViewportWithCount ) 1347 vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; 1348 vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) ); 1349 if ( !vkCmdSetScissorWithCount ) 1350 vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; 1351 vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) ); 1352 if ( !vkCmdBindVertexBuffers2 ) 1353 vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; 1354 vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) ); 1355 if ( !vkCmdSetDepthTestEnable ) 1356 vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; 1357 vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) ); 1358 if ( !vkCmdSetDepthWriteEnable ) 1359 vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; 1360 vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) ); 1361 if ( !vkCmdSetDepthCompareOp ) 1362 vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; 1363 vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) ); 1364 if ( !vkCmdSetDepthBoundsTestEnable ) 1365 vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; 1366 vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) ); 1367 if ( !vkCmdSetStencilTestEnable ) 1368 vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; 1369 vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) ); 1370 if ( !vkCmdSetStencilOp ) 1371 vkCmdSetStencilOp = vkCmdSetStencilOpEXT; 1372 1373 //=== VK_KHR_deferred_host_operations === 1374 vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) ); 1375 vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) ); 1376 vkGetDeferredOperationMaxConcurrencyKHR = 1377 PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); 1378 vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) ); 1379 vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) ); 1380 1381 //=== VK_KHR_pipeline_executable_properties === 1382 vkGetPipelineExecutablePropertiesKHR = 1383 PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) ); 1384 vkGetPipelineExecutableStatisticsKHR = 1385 PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) ); 1386 vkGetPipelineExecutableInternalRepresentationsKHR = 1387 PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); 1388 1389 //=== VK_EXT_host_image_copy === 1390 vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToImageEXT" ) ); 1391 if ( !vkCopyMemoryToImage ) 1392 vkCopyMemoryToImage = vkCopyMemoryToImageEXT; 1393 vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyImageToMemoryEXT" ) ); 1394 if ( !vkCopyImageToMemory ) 1395 vkCopyImageToMemory = vkCopyImageToMemoryEXT; 1396 vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetDeviceProcAddr( device, "vkCopyImageToImageEXT" ) ); 1397 if ( !vkCopyImageToImage ) 1398 vkCopyImageToImage = vkCopyImageToImageEXT; 1399 vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetDeviceProcAddr( device, "vkTransitionImageLayoutEXT" ) ); 1400 if ( !vkTransitionImageLayout ) 1401 vkTransitionImageLayout = vkTransitionImageLayoutEXT; 1402 vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) ); 1403 if ( !vkGetImageSubresourceLayout2 ) 1404 vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2EXT; 1405 1406 //=== VK_KHR_map_memory2 === 1407 vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) ); 1408 if ( !vkMapMemory2 ) 1409 vkMapMemory2 = vkMapMemory2KHR; 1410 vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) ); 1411 if ( !vkUnmapMemory2 ) 1412 vkUnmapMemory2 = vkUnmapMemory2KHR; 1413 1414 //=== VK_EXT_swapchain_maintenance1 === 1415 vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) ); 1416 1417 //=== VK_NV_device_generated_commands === 1418 vkGetGeneratedCommandsMemoryRequirementsNV = 1419 PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); 1420 vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) ); 1421 vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) ); 1422 vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) ); 1423 vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) ); 1424 vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) ); 1425 1426 //=== VK_EXT_depth_bias_control === 1427 vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias2EXT" ) ); 1428 1429 //=== VK_EXT_private_data === 1430 vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) ); 1431 if ( !vkCreatePrivateDataSlot ) 1432 vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; 1433 vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) ); 1434 if ( !vkDestroyPrivateDataSlot ) 1435 vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; 1436 vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) ); 1437 if ( !vkSetPrivateData ) 1438 vkSetPrivateData = vkSetPrivateDataEXT; 1439 vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) ); 1440 if ( !vkGetPrivateData ) 1441 vkGetPrivateData = vkGetPrivateDataEXT; 1442 1443 //=== VK_KHR_video_encode_queue === 1444 vkGetEncodedVideoSessionParametersKHR = 1445 PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) ); 1446 vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) ); 1447 1448 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 1449 //=== VK_NV_cuda_kernel_launch === 1450 vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetDeviceProcAddr( device, "vkCreateCudaModuleNV" ) ); 1451 vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetDeviceProcAddr( device, "vkGetCudaModuleCacheNV" ) ); 1452 vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetDeviceProcAddr( device, "vkCreateCudaFunctionNV" ) ); 1453 vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetDeviceProcAddr( device, "vkDestroyCudaModuleNV" ) ); 1454 vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetDeviceProcAddr( device, "vkDestroyCudaFunctionNV" ) ); 1455 vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) ); 1456 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 1457 1458 # if defined( VK_USE_PLATFORM_METAL_EXT ) 1459 //=== VK_EXT_metal_objects === 1460 vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) ); 1461 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 1462 1463 //=== VK_KHR_synchronization2 === 1464 vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) ); 1465 if ( !vkCmdSetEvent2 ) 1466 vkCmdSetEvent2 = vkCmdSetEvent2KHR; 1467 vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) ); 1468 if ( !vkCmdResetEvent2 ) 1469 vkCmdResetEvent2 = vkCmdResetEvent2KHR; 1470 vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) ); 1471 if ( !vkCmdWaitEvents2 ) 1472 vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; 1473 vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) ); 1474 if ( !vkCmdPipelineBarrier2 ) 1475 vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; 1476 vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) ); 1477 if ( !vkCmdWriteTimestamp2 ) 1478 vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; 1479 vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) ); 1480 if ( !vkQueueSubmit2 ) 1481 vkQueueSubmit2 = vkQueueSubmit2KHR; 1482 vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) ); 1483 vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) ); 1484 1485 //=== VK_EXT_descriptor_buffer === 1486 vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) ); 1487 vkGetDescriptorSetLayoutBindingOffsetEXT = 1488 PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) ); 1489 vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) ); 1490 vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) ); 1491 vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) ); 1492 vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 1493 PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) ); 1494 vkGetBufferOpaqueCaptureDescriptorDataEXT = 1495 PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) ); 1496 vkGetImageOpaqueCaptureDescriptorDataEXT = 1497 PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) ); 1498 vkGetImageViewOpaqueCaptureDescriptorDataEXT = 1499 PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) ); 1500 vkGetSamplerOpaqueCaptureDescriptorDataEXT = 1501 PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) ); 1502 vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( 1503 vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); 1504 1505 //=== VK_NV_fragment_shading_rate_enums === 1506 vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) ); 1507 1508 //=== VK_EXT_mesh_shader === 1509 vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) ); 1510 vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) ); 1511 vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) ); 1512 1513 //=== VK_KHR_copy_commands2 === 1514 vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) ); 1515 if ( !vkCmdCopyBuffer2 ) 1516 vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; 1517 vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) ); 1518 if ( !vkCmdCopyImage2 ) 1519 vkCmdCopyImage2 = vkCmdCopyImage2KHR; 1520 vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) ); 1521 if ( !vkCmdCopyBufferToImage2 ) 1522 vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; 1523 vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) ); 1524 if ( !vkCmdCopyImageToBuffer2 ) 1525 vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; 1526 vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) ); 1527 if ( !vkCmdBlitImage2 ) 1528 vkCmdBlitImage2 = vkCmdBlitImage2KHR; 1529 vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) ); 1530 if ( !vkCmdResolveImage2 ) 1531 vkCmdResolveImage2 = vkCmdResolveImage2KHR; 1532 1533 //=== VK_EXT_device_fault === 1534 vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) ); 1535 1536 //=== VK_EXT_vertex_input_dynamic_state === 1537 vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) ); 1538 1539 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1540 //=== VK_FUCHSIA_external_memory === 1541 vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) ); 1542 vkGetMemoryZirconHandlePropertiesFUCHSIA = 1543 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); 1544 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1545 1546 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1547 //=== VK_FUCHSIA_external_semaphore === 1548 vkImportSemaphoreZirconHandleFUCHSIA = 1549 PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); 1550 vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); 1551 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1552 1553 # if defined( VK_USE_PLATFORM_FUCHSIA ) 1554 //=== VK_FUCHSIA_buffer_collection === 1555 vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) ); 1556 vkSetBufferCollectionImageConstraintsFUCHSIA = 1557 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); 1558 vkSetBufferCollectionBufferConstraintsFUCHSIA = 1559 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); 1560 vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) ); 1561 vkGetBufferCollectionPropertiesFUCHSIA = 1562 PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); 1563 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 1564 1565 //=== VK_HUAWEI_subpass_shading === 1566 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 1567 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); 1568 vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) ); 1569 1570 //=== VK_HUAWEI_invocation_mask === 1571 vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) ); 1572 1573 //=== VK_NV_external_memory_rdma === 1574 vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) ); 1575 1576 //=== VK_EXT_pipeline_properties === 1577 vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) ); 1578 1579 //=== VK_EXT_extended_dynamic_state2 === 1580 vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) ); 1581 vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) ); 1582 if ( !vkCmdSetRasterizerDiscardEnable ) 1583 vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; 1584 vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) ); 1585 if ( !vkCmdSetDepthBiasEnable ) 1586 vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; 1587 vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) ); 1588 vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) ); 1589 if ( !vkCmdSetPrimitiveRestartEnable ) 1590 vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; 1591 1592 //=== VK_EXT_color_write_enable === 1593 vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) ); 1594 1595 //=== VK_KHR_ray_tracing_maintenance1 === 1596 vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) ); 1597 1598 //=== VK_EXT_multi_draw === 1599 vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) ); 1600 vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) ); 1601 1602 //=== VK_EXT_opacity_micromap === 1603 vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) ); 1604 vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) ); 1605 vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) ); 1606 vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) ); 1607 vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) ); 1608 vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) ); 1609 vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) ); 1610 vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) ); 1611 vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) ); 1612 vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) ); 1613 vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) ); 1614 vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) ); 1615 vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) ); 1616 vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) ); 1617 1618 //=== VK_HUAWEI_cluster_culling_shader === 1619 vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterHUAWEI" ) ); 1620 vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterIndirectHUAWEI" ) ); 1621 1622 //=== VK_EXT_pageable_device_local_memory === 1623 vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) ); 1624 1625 //=== VK_KHR_maintenance4 === 1626 vkGetDeviceBufferMemoryRequirementsKHR = 1627 PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); 1628 if ( !vkGetDeviceBufferMemoryRequirements ) 1629 vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; 1630 vkGetDeviceImageMemoryRequirementsKHR = 1631 PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) ); 1632 if ( !vkGetDeviceImageMemoryRequirements ) 1633 vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; 1634 vkGetDeviceImageSparseMemoryRequirementsKHR = 1635 PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); 1636 if ( !vkGetDeviceImageSparseMemoryRequirements ) 1637 vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; 1638 1639 //=== VK_VALVE_descriptor_set_host_mapping === 1640 vkGetDescriptorSetLayoutHostMappingInfoVALVE = 1641 PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) ); 1642 vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) ); 1643 1644 //=== VK_NV_copy_memory_indirect === 1645 vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) ); 1646 vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) ); 1647 1648 //=== VK_NV_memory_decompression === 1649 vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) ); 1650 vkCmdDecompressMemoryIndirectCountNV = 1651 PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) ); 1652 1653 //=== VK_NV_device_generated_commands_compute === 1654 vkGetPipelineIndirectMemoryRequirementsNV = 1655 PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectMemoryRequirementsNV" ) ); 1656 vkCmdUpdatePipelineIndirectBufferNV = PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetDeviceProcAddr( device, "vkCmdUpdatePipelineIndirectBufferNV" ) ); 1657 vkGetPipelineIndirectDeviceAddressNV = 1658 PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) ); 1659 1660 //=== VK_EXT_extended_dynamic_state3 === 1661 vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) ); 1662 vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) ); 1663 vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) ); 1664 vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) ); 1665 vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) ); 1666 vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) ); 1667 vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) ); 1668 vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) ); 1669 vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) ); 1670 vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) ); 1671 vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) ); 1672 vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) ); 1673 vkCmdSetConservativeRasterizationModeEXT = 1674 PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) ); 1675 vkCmdSetExtraPrimitiveOverestimationSizeEXT = 1676 PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) ); 1677 vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) ); 1678 vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) ); 1679 vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) ); 1680 vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) ); 1681 vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) ); 1682 vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) ); 1683 vkCmdSetDepthClipNegativeOneToOneEXT = 1684 PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) ); 1685 vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) ); 1686 vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) ); 1687 vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) ); 1688 vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) ); 1689 vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) ); 1690 vkCmdSetCoverageModulationTableEnableNV = 1691 PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) ); 1692 vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) ); 1693 vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) ); 1694 vkCmdSetRepresentativeFragmentTestEnableNV = 1695 PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) ); 1696 vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) ); 1697 1698 //=== VK_EXT_shader_module_identifier === 1699 vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) ); 1700 vkGetShaderModuleCreateInfoIdentifierEXT = 1701 PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) ); 1702 1703 //=== VK_NV_optical_flow === 1704 vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) ); 1705 vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) ); 1706 vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) ); 1707 vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) ); 1708 1709 //=== VK_KHR_maintenance5 === 1710 vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2KHR" ) ); 1711 if ( !vkCmdBindIndexBuffer2 ) 1712 vkCmdBindIndexBuffer2 = vkCmdBindIndexBuffer2KHR; 1713 vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularityKHR" ) ); 1714 if ( !vkGetRenderingAreaGranularity ) 1715 vkGetRenderingAreaGranularity = vkGetRenderingAreaGranularityKHR; 1716 vkGetDeviceImageSubresourceLayoutKHR = 1717 PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayoutKHR" ) ); 1718 if ( !vkGetDeviceImageSubresourceLayout ) 1719 vkGetDeviceImageSubresourceLayout = vkGetDeviceImageSubresourceLayoutKHR; 1720 vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2KHR" ) ); 1721 if ( !vkGetImageSubresourceLayout2 ) 1722 vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2KHR; 1723 1724 //=== VK_AMD_anti_lag === 1725 vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetDeviceProcAddr( device, "vkAntiLagUpdateAMD" ) ); 1726 1727 //=== VK_EXT_shader_object === 1728 vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) ); 1729 vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) ); 1730 vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) ); 1731 vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) ); 1732 1733 //=== VK_KHR_pipeline_binary === 1734 vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetDeviceProcAddr( device, "vkCreatePipelineBinariesKHR" ) ); 1735 vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetDeviceProcAddr( device, "vkDestroyPipelineBinaryKHR" ) ); 1736 vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetDeviceProcAddr( device, "vkGetPipelineKeyKHR" ) ); 1737 vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetDeviceProcAddr( device, "vkGetPipelineBinaryDataKHR" ) ); 1738 vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetDeviceProcAddr( device, "vkReleaseCapturedPipelineDataKHR" ) ); 1739 1740 //=== VK_QCOM_tile_properties === 1741 vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) ); 1742 vkGetDynamicRenderingTilePropertiesQCOM = 1743 PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) ); 1744 1745 //=== VK_NV_low_latency2 === 1746 vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) ); 1747 vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) ); 1748 vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) ); 1749 vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) ); 1750 vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) ); 1751 1752 //=== VK_EXT_attachment_feedback_loop_dynamic_state === 1753 vkCmdSetAttachmentFeedbackLoopEnableEXT = 1754 PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) ); 1755 1756 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 1757 //=== VK_QNX_external_memory_screen_buffer === 1758 vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) ); 1759 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 1760 1761 //=== VK_KHR_line_rasterization === 1762 vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) ); 1763 if ( !vkCmdSetLineStipple ) 1764 vkCmdSetLineStipple = vkCmdSetLineStippleKHR; 1765 1766 //=== VK_KHR_calibrated_timestamps === 1767 vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) ); 1768 1769 //=== VK_KHR_maintenance6 === 1770 vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2KHR" ) ); 1771 if ( !vkCmdBindDescriptorSets2 ) 1772 vkCmdBindDescriptorSets2 = vkCmdBindDescriptorSets2KHR; 1773 vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetDeviceProcAddr( device, "vkCmdPushConstants2KHR" ) ); 1774 if ( !vkCmdPushConstants2 ) 1775 vkCmdPushConstants2 = vkCmdPushConstants2KHR; 1776 vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2KHR" ) ); 1777 if ( !vkCmdPushDescriptorSet2 ) 1778 vkCmdPushDescriptorSet2 = vkCmdPushDescriptorSet2KHR; 1779 vkCmdPushDescriptorSetWithTemplate2KHR = 1780 PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2KHR" ) ); 1781 if ( !vkCmdPushDescriptorSetWithTemplate2 ) 1782 vkCmdPushDescriptorSetWithTemplate2 = vkCmdPushDescriptorSetWithTemplate2KHR; 1783 vkCmdSetDescriptorBufferOffsets2EXT = PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsets2EXT" ) ); 1784 vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 1785 PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); 1786 } 1787 1788 public: 1789 //=== VK_VERSION_1_0 === 1790 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; 1791 PFN_vkDestroyDevice vkDestroyDevice = 0; 1792 PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; 1793 PFN_vkQueueSubmit vkQueueSubmit = 0; 1794 PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; 1795 PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; 1796 PFN_vkAllocateMemory vkAllocateMemory = 0; 1797 PFN_vkFreeMemory vkFreeMemory = 0; 1798 PFN_vkMapMemory vkMapMemory = 0; 1799 PFN_vkUnmapMemory vkUnmapMemory = 0; 1800 PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; 1801 PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; 1802 PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; 1803 PFN_vkBindBufferMemory vkBindBufferMemory = 0; 1804 PFN_vkBindImageMemory vkBindImageMemory = 0; 1805 PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; 1806 PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; 1807 PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; 1808 PFN_vkQueueBindSparse vkQueueBindSparse = 0; 1809 PFN_vkCreateFence vkCreateFence = 0; 1810 PFN_vkDestroyFence vkDestroyFence = 0; 1811 PFN_vkResetFences vkResetFences = 0; 1812 PFN_vkGetFenceStatus vkGetFenceStatus = 0; 1813 PFN_vkWaitForFences vkWaitForFences = 0; 1814 PFN_vkCreateSemaphore vkCreateSemaphore = 0; 1815 PFN_vkDestroySemaphore vkDestroySemaphore = 0; 1816 PFN_vkCreateEvent vkCreateEvent = 0; 1817 PFN_vkDestroyEvent vkDestroyEvent = 0; 1818 PFN_vkGetEventStatus vkGetEventStatus = 0; 1819 PFN_vkSetEvent vkSetEvent = 0; 1820 PFN_vkResetEvent vkResetEvent = 0; 1821 PFN_vkCreateQueryPool vkCreateQueryPool = 0; 1822 PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; 1823 PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; 1824 PFN_vkCreateBuffer vkCreateBuffer = 0; 1825 PFN_vkDestroyBuffer vkDestroyBuffer = 0; 1826 PFN_vkCreateBufferView vkCreateBufferView = 0; 1827 PFN_vkDestroyBufferView vkDestroyBufferView = 0; 1828 PFN_vkCreateImage vkCreateImage = 0; 1829 PFN_vkDestroyImage vkDestroyImage = 0; 1830 PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; 1831 PFN_vkCreateImageView vkCreateImageView = 0; 1832 PFN_vkDestroyImageView vkDestroyImageView = 0; 1833 PFN_vkCreateShaderModule vkCreateShaderModule = 0; 1834 PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; 1835 PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; 1836 PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; 1837 PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; 1838 PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; 1839 PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; 1840 PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; 1841 PFN_vkDestroyPipeline vkDestroyPipeline = 0; 1842 PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; 1843 PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; 1844 PFN_vkCreateSampler vkCreateSampler = 0; 1845 PFN_vkDestroySampler vkDestroySampler = 0; 1846 PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; 1847 PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; 1848 PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; 1849 PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; 1850 PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; 1851 PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; 1852 PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; 1853 PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; 1854 PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; 1855 PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; 1856 PFN_vkCreateRenderPass vkCreateRenderPass = 0; 1857 PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; 1858 PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; 1859 PFN_vkCreateCommandPool vkCreateCommandPool = 0; 1860 PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; 1861 PFN_vkResetCommandPool vkResetCommandPool = 0; 1862 PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; 1863 PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; 1864 PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; 1865 PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; 1866 PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; 1867 PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; 1868 PFN_vkCmdSetViewport vkCmdSetViewport = 0; 1869 PFN_vkCmdSetScissor vkCmdSetScissor = 0; 1870 PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; 1871 PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; 1872 PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; 1873 PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; 1874 PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; 1875 PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; 1876 PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; 1877 PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; 1878 PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; 1879 PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; 1880 PFN_vkCmdDraw vkCmdDraw = 0; 1881 PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; 1882 PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; 1883 PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; 1884 PFN_vkCmdDispatch vkCmdDispatch = 0; 1885 PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; 1886 PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; 1887 PFN_vkCmdCopyImage vkCmdCopyImage = 0; 1888 PFN_vkCmdBlitImage vkCmdBlitImage = 0; 1889 PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; 1890 PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; 1891 PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; 1892 PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; 1893 PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; 1894 PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; 1895 PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; 1896 PFN_vkCmdResolveImage vkCmdResolveImage = 0; 1897 PFN_vkCmdSetEvent vkCmdSetEvent = 0; 1898 PFN_vkCmdResetEvent vkCmdResetEvent = 0; 1899 PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; 1900 PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; 1901 PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; 1902 PFN_vkCmdEndQuery vkCmdEndQuery = 0; 1903 PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; 1904 PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; 1905 PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; 1906 PFN_vkCmdPushConstants vkCmdPushConstants = 0; 1907 PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; 1908 PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; 1909 PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; 1910 PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; 1911 1912 //=== VK_VERSION_1_1 === 1913 PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; 1914 PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; 1915 PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; 1916 PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; 1917 PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; 1918 PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; 1919 PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; 1920 PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; 1921 PFN_vkTrimCommandPool vkTrimCommandPool = 0; 1922 PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; 1923 PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; 1924 PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; 1925 PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; 1926 PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; 1927 PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; 1928 PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; 1929 1930 //=== VK_VERSION_1_2 === 1931 PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0; 1932 PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0; 1933 PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; 1934 PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0; 1935 PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0; 1936 PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0; 1937 PFN_vkResetQueryPool vkResetQueryPool = 0; 1938 PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0; 1939 PFN_vkWaitSemaphores vkWaitSemaphores = 0; 1940 PFN_vkSignalSemaphore vkSignalSemaphore = 0; 1941 PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0; 1942 PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0; 1943 PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0; 1944 1945 //=== VK_VERSION_1_3 === 1946 PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0; 1947 PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0; 1948 PFN_vkSetPrivateData vkSetPrivateData = 0; 1949 PFN_vkGetPrivateData vkGetPrivateData = 0; 1950 PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0; 1951 PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0; 1952 PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0; 1953 PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0; 1954 PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0; 1955 PFN_vkQueueSubmit2 vkQueueSubmit2 = 0; 1956 PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0; 1957 PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0; 1958 PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0; 1959 PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0; 1960 PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0; 1961 PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0; 1962 PFN_vkCmdBeginRendering vkCmdBeginRendering = 0; 1963 PFN_vkCmdEndRendering vkCmdEndRendering = 0; 1964 PFN_vkCmdSetCullMode vkCmdSetCullMode = 0; 1965 PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0; 1966 PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0; 1967 PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0; 1968 PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0; 1969 PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0; 1970 PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0; 1971 PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0; 1972 PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0; 1973 PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0; 1974 PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0; 1975 PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0; 1976 PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0; 1977 PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0; 1978 PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0; 1979 PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0; 1980 PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0; 1981 PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0; 1982 1983 //=== VK_VERSION_1_4 === 1984 PFN_vkCmdSetLineStipple vkCmdSetLineStipple = 0; 1985 PFN_vkMapMemory2 vkMapMemory2 = 0; 1986 PFN_vkUnmapMemory2 vkUnmapMemory2 = 0; 1987 PFN_vkCmdBindIndexBuffer2 vkCmdBindIndexBuffer2 = 0; 1988 PFN_vkGetRenderingAreaGranularity vkGetRenderingAreaGranularity = 0; 1989 PFN_vkGetDeviceImageSubresourceLayout vkGetDeviceImageSubresourceLayout = 0; 1990 PFN_vkGetImageSubresourceLayout2 vkGetImageSubresourceLayout2 = 0; 1991 PFN_vkCmdPushDescriptorSet vkCmdPushDescriptorSet = 0; 1992 PFN_vkCmdPushDescriptorSetWithTemplate vkCmdPushDescriptorSetWithTemplate = 0; 1993 PFN_vkCmdSetRenderingAttachmentLocations vkCmdSetRenderingAttachmentLocations = 0; 1994 PFN_vkCmdSetRenderingInputAttachmentIndices vkCmdSetRenderingInputAttachmentIndices = 0; 1995 PFN_vkCmdBindDescriptorSets2 vkCmdBindDescriptorSets2 = 0; 1996 PFN_vkCmdPushConstants2 vkCmdPushConstants2 = 0; 1997 PFN_vkCmdPushDescriptorSet2 vkCmdPushDescriptorSet2 = 0; 1998 PFN_vkCmdPushDescriptorSetWithTemplate2 vkCmdPushDescriptorSetWithTemplate2 = 0; 1999 PFN_vkCopyMemoryToImage vkCopyMemoryToImage = 0; 2000 PFN_vkCopyImageToMemory vkCopyImageToMemory = 0; 2001 PFN_vkCopyImageToImage vkCopyImageToImage = 0; 2002 PFN_vkTransitionImageLayout vkTransitionImageLayout = 0; 2003 2004 //=== VK_KHR_swapchain === 2005 PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; 2006 PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; 2007 PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; 2008 PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; 2009 PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; 2010 PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; 2011 PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; 2012 PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; 2013 2014 //=== VK_KHR_display_swapchain === 2015 PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; 2016 2017 //=== VK_EXT_debug_marker === 2018 PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; 2019 PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; 2020 PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; 2021 PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; 2022 PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; 2023 2024 //=== VK_KHR_video_queue === 2025 PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0; 2026 PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0; 2027 PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0; 2028 PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0; 2029 PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0; 2030 PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0; 2031 PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0; 2032 PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0; 2033 PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0; 2034 PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0; 2035 2036 //=== VK_KHR_video_decode_queue === 2037 PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0; 2038 2039 //=== VK_EXT_transform_feedback === 2040 PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; 2041 PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; 2042 PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; 2043 PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; 2044 PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; 2045 PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; 2046 2047 //=== VK_NVX_binary_import === 2048 PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0; 2049 PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0; 2050 PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0; 2051 PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0; 2052 PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; 2053 2054 //=== VK_NVX_image_view_handle === 2055 PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; 2056 PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; 2057 2058 //=== VK_AMD_draw_indirect_count === 2059 PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; 2060 PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; 2061 2062 //=== VK_AMD_shader_info === 2063 PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; 2064 2065 //=== VK_KHR_dynamic_rendering === 2066 PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0; 2067 PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0; 2068 2069 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2070 //=== VK_NV_external_memory_win32 === 2071 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; 2072 # else 2073 PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; 2074 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2075 2076 //=== VK_KHR_device_group === 2077 PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; 2078 PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; 2079 PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; 2080 2081 //=== VK_KHR_maintenance1 === 2082 PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; 2083 2084 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2085 //=== VK_KHR_external_memory_win32 === 2086 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; 2087 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; 2088 # else 2089 PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; 2090 PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; 2091 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2092 2093 //=== VK_KHR_external_memory_fd === 2094 PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; 2095 PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; 2096 2097 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2098 //=== VK_KHR_external_semaphore_win32 === 2099 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; 2100 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; 2101 # else 2102 PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; 2103 PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; 2104 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2105 2106 //=== VK_KHR_external_semaphore_fd === 2107 PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; 2108 PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; 2109 2110 //=== VK_KHR_push_descriptor === 2111 PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; 2112 PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; 2113 2114 //=== VK_EXT_conditional_rendering === 2115 PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; 2116 PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; 2117 2118 //=== VK_KHR_descriptor_update_template === 2119 PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; 2120 PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; 2121 PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; 2122 2123 //=== VK_NV_clip_space_w_scaling === 2124 PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; 2125 2126 //=== VK_EXT_display_control === 2127 PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; 2128 PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; 2129 PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; 2130 PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; 2131 2132 //=== VK_GOOGLE_display_timing === 2133 PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; 2134 PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; 2135 2136 //=== VK_EXT_discard_rectangles === 2137 PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; 2138 PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0; 2139 PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0; 2140 2141 //=== VK_EXT_hdr_metadata === 2142 PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; 2143 2144 //=== VK_KHR_create_renderpass2 === 2145 PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; 2146 PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; 2147 PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0; 2148 PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; 2149 2150 //=== VK_KHR_shared_presentable_image === 2151 PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; 2152 2153 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2154 //=== VK_KHR_external_fence_win32 === 2155 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; 2156 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; 2157 # else 2158 PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; 2159 PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; 2160 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2161 2162 //=== VK_KHR_external_fence_fd === 2163 PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; 2164 PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; 2165 2166 //=== VK_KHR_performance_query === 2167 PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; 2168 PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; 2169 2170 //=== VK_EXT_debug_utils === 2171 PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; 2172 PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; 2173 PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; 2174 PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; 2175 PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; 2176 PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; 2177 PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; 2178 PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; 2179 2180 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 2181 //=== VK_ANDROID_external_memory_android_hardware_buffer === 2182 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; 2183 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; 2184 # else 2185 PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; 2186 PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; 2187 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 2188 2189 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2190 //=== VK_AMDX_shader_enqueue === 2191 PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0; 2192 PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX = 0; 2193 PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX = 0; 2194 PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX = 0; 2195 PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX = 0; 2196 PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX = 0; 2197 PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX = 0; 2198 # else 2199 PFN_dummy vkCreateExecutionGraphPipelinesAMDX_placeholder = 0; 2200 PFN_dummy vkGetExecutionGraphPipelineScratchSizeAMDX_placeholder = 0; 2201 PFN_dummy vkGetExecutionGraphPipelineNodeIndexAMDX_placeholder = 0; 2202 PFN_dummy vkCmdInitializeGraphScratchMemoryAMDX_placeholder = 0; 2203 PFN_dummy vkCmdDispatchGraphAMDX_placeholder = 0; 2204 PFN_dummy vkCmdDispatchGraphIndirectAMDX_placeholder = 0; 2205 PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0; 2206 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2207 2208 //=== VK_EXT_sample_locations === 2209 PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; 2210 2211 //=== VK_KHR_get_memory_requirements2 === 2212 PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; 2213 PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; 2214 PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; 2215 2216 //=== VK_KHR_acceleration_structure === 2217 PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0; 2218 PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0; 2219 PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0; 2220 PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0; 2221 PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0; 2222 PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0; 2223 PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0; 2224 PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0; 2225 PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0; 2226 PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0; 2227 PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0; 2228 PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; 2229 PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0; 2230 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0; 2231 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0; 2232 PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0; 2233 2234 //=== VK_KHR_ray_tracing_pipeline === 2235 PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0; 2236 PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0; 2237 PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0; 2238 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0; 2239 PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0; 2240 PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0; 2241 PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; 2242 2243 //=== VK_KHR_sampler_ycbcr_conversion === 2244 PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; 2245 PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; 2246 2247 //=== VK_KHR_bind_memory2 === 2248 PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; 2249 PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; 2250 2251 //=== VK_EXT_image_drm_format_modifier === 2252 PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; 2253 2254 //=== VK_EXT_validation_cache === 2255 PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; 2256 PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; 2257 PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; 2258 PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; 2259 2260 //=== VK_NV_shading_rate_image === 2261 PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; 2262 PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; 2263 PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; 2264 2265 //=== VK_NV_ray_tracing === 2266 PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; 2267 PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; 2268 PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; 2269 PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; 2270 PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; 2271 PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; 2272 PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; 2273 PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; 2274 PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; 2275 PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; 2276 PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; 2277 PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; 2278 2279 //=== VK_KHR_maintenance3 === 2280 PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; 2281 2282 //=== VK_KHR_draw_indirect_count === 2283 PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; 2284 PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; 2285 2286 //=== VK_EXT_external_memory_host === 2287 PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; 2288 2289 //=== VK_AMD_buffer_marker === 2290 PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; 2291 2292 //=== VK_EXT_calibrated_timestamps === 2293 PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0; 2294 2295 //=== VK_NV_mesh_shader === 2296 PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; 2297 PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; 2298 PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; 2299 2300 //=== VK_NV_scissor_exclusive === 2301 PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0; 2302 PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; 2303 2304 //=== VK_NV_device_diagnostic_checkpoints === 2305 PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; 2306 PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0; 2307 2308 //=== VK_KHR_timeline_semaphore === 2309 PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0; 2310 PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; 2311 PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; 2312 2313 //=== VK_INTEL_performance_query === 2314 PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; 2315 PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; 2316 PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; 2317 PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; 2318 PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; 2319 PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; 2320 PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; 2321 PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; 2322 PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; 2323 2324 //=== VK_AMD_display_native_hdr === 2325 PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; 2326 2327 //=== VK_KHR_fragment_shading_rate === 2328 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0; 2329 2330 //=== VK_KHR_dynamic_rendering_local_read === 2331 PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR = 0; 2332 PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0; 2333 2334 //=== VK_EXT_buffer_device_address === 2335 PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; 2336 2337 //=== VK_KHR_present_wait === 2338 PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0; 2339 2340 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2341 //=== VK_EXT_full_screen_exclusive === 2342 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; 2343 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; 2344 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; 2345 # else 2346 PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; 2347 PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; 2348 PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; 2349 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2350 2351 //=== VK_KHR_buffer_device_address === 2352 PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0; 2353 PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0; 2354 PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0; 2355 2356 //=== VK_EXT_line_rasterization === 2357 PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; 2358 2359 //=== VK_EXT_host_query_reset === 2360 PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; 2361 2362 //=== VK_EXT_extended_dynamic_state === 2363 PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; 2364 PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; 2365 PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; 2366 PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0; 2367 PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0; 2368 PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0; 2369 PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0; 2370 PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0; 2371 PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; 2372 PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; 2373 PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0; 2374 PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0; 2375 2376 //=== VK_KHR_deferred_host_operations === 2377 PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; 2378 PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; 2379 PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0; 2380 PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0; 2381 PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0; 2382 2383 //=== VK_KHR_pipeline_executable_properties === 2384 PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; 2385 PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; 2386 PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; 2387 2388 //=== VK_EXT_host_image_copy === 2389 PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT = 0; 2390 PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT = 0; 2391 PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT = 0; 2392 PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT = 0; 2393 PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 0; 2394 2395 //=== VK_KHR_map_memory2 === 2396 PFN_vkMapMemory2KHR vkMapMemory2KHR = 0; 2397 PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0; 2398 2399 //=== VK_EXT_swapchain_maintenance1 === 2400 PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0; 2401 2402 //=== VK_NV_device_generated_commands === 2403 PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0; 2404 PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0; 2405 PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0; 2406 PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0; 2407 PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0; 2408 PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0; 2409 2410 //=== VK_EXT_depth_bias_control === 2411 PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT = 0; 2412 2413 //=== VK_EXT_private_data === 2414 PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0; 2415 PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0; 2416 PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0; 2417 PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0; 2418 2419 //=== VK_KHR_video_encode_queue === 2420 PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR = 0; 2421 PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; 2422 2423 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2424 //=== VK_NV_cuda_kernel_launch === 2425 PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV = 0; 2426 PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV = 0; 2427 PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV = 0; 2428 PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV = 0; 2429 PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV = 0; 2430 PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV = 0; 2431 # else 2432 PFN_dummy vkCreateCudaModuleNV_placeholder = 0; 2433 PFN_dummy vkGetCudaModuleCacheNV_placeholder = 0; 2434 PFN_dummy vkCreateCudaFunctionNV_placeholder = 0; 2435 PFN_dummy vkDestroyCudaModuleNV_placeholder = 0; 2436 PFN_dummy vkDestroyCudaFunctionNV_placeholder = 0; 2437 PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0; 2438 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2439 2440 # if defined( VK_USE_PLATFORM_METAL_EXT ) 2441 //=== VK_EXT_metal_objects === 2442 PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0; 2443 # else 2444 PFN_dummy vkExportMetalObjectsEXT_placeholder = 0; 2445 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 2446 2447 //=== VK_KHR_synchronization2 === 2448 PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0; 2449 PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0; 2450 PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0; 2451 PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0; 2452 PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0; 2453 PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0; 2454 PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0; 2455 PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0; 2456 2457 //=== VK_EXT_descriptor_buffer === 2458 PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT = 0; 2459 PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT = 0; 2460 PFN_vkGetDescriptorEXT vkGetDescriptorEXT = 0; 2461 PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT = 0; 2462 PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT = 0; 2463 PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 0; 2464 PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT = 0; 2465 PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT = 0; 2466 PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT = 0; 2467 PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0; 2468 PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0; 2469 2470 //=== VK_NV_fragment_shading_rate_enums === 2471 PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; 2472 2473 //=== VK_EXT_mesh_shader === 2474 PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0; 2475 PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0; 2476 PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0; 2477 2478 //=== VK_KHR_copy_commands2 === 2479 PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0; 2480 PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0; 2481 PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0; 2482 PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; 2483 PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0; 2484 PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0; 2485 2486 //=== VK_EXT_device_fault === 2487 PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0; 2488 2489 //=== VK_EXT_vertex_input_dynamic_state === 2490 PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0; 2491 2492 # if defined( VK_USE_PLATFORM_FUCHSIA ) 2493 //=== VK_FUCHSIA_external_memory === 2494 PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; 2495 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; 2496 # else 2497 PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; 2498 PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; 2499 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 2500 2501 # if defined( VK_USE_PLATFORM_FUCHSIA ) 2502 //=== VK_FUCHSIA_external_semaphore === 2503 PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; 2504 PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; 2505 # else 2506 PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; 2507 PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; 2508 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 2509 2510 # if defined( VK_USE_PLATFORM_FUCHSIA ) 2511 //=== VK_FUCHSIA_buffer_collection === 2512 PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0; 2513 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0; 2514 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0; 2515 PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; 2516 PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; 2517 # else 2518 PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; 2519 PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; 2520 PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; 2521 PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; 2522 PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; 2523 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 2524 2525 //=== VK_HUAWEI_subpass_shading === 2526 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0; 2527 PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0; 2528 2529 //=== VK_HUAWEI_invocation_mask === 2530 PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0; 2531 2532 //=== VK_NV_external_memory_rdma === 2533 PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0; 2534 2535 //=== VK_EXT_pipeline_properties === 2536 PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 0; 2537 2538 //=== VK_EXT_extended_dynamic_state2 === 2539 PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; 2540 PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; 2541 PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; 2542 PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; 2543 PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; 2544 2545 //=== VK_EXT_color_write_enable === 2546 PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; 2547 2548 //=== VK_KHR_ray_tracing_maintenance1 === 2549 PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 0; 2550 2551 //=== VK_EXT_multi_draw === 2552 PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0; 2553 PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0; 2554 2555 //=== VK_EXT_opacity_micromap === 2556 PFN_vkCreateMicromapEXT vkCreateMicromapEXT = 0; 2557 PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT = 0; 2558 PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT = 0; 2559 PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT = 0; 2560 PFN_vkCopyMicromapEXT vkCopyMicromapEXT = 0; 2561 PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT = 0; 2562 PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT = 0; 2563 PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT = 0; 2564 PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT = 0; 2565 PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT = 0; 2566 PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT = 0; 2567 PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT = 0; 2568 PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT = 0; 2569 PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT = 0; 2570 2571 //=== VK_HUAWEI_cluster_culling_shader === 2572 PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI = 0; 2573 PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI = 0; 2574 2575 //=== VK_EXT_pageable_device_local_memory === 2576 PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0; 2577 2578 //=== VK_KHR_maintenance4 === 2579 PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0; 2580 PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0; 2581 PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0; 2582 2583 //=== VK_VALVE_descriptor_set_host_mapping === 2584 PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0; 2585 PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0; 2586 2587 //=== VK_NV_copy_memory_indirect === 2588 PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV = 0; 2589 PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV = 0; 2590 2591 //=== VK_NV_memory_decompression === 2592 PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV = 0; 2593 PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV = 0; 2594 2595 //=== VK_NV_device_generated_commands_compute === 2596 PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV = 0; 2597 PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV = 0; 2598 PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV = 0; 2599 2600 //=== VK_EXT_extended_dynamic_state3 === 2601 PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT = 0; 2602 PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT = 0; 2603 PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT = 0; 2604 PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT = 0; 2605 PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT = 0; 2606 PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT = 0; 2607 PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT = 0; 2608 PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT = 0; 2609 PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT = 0; 2610 PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT = 0; 2611 PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT = 0; 2612 PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT = 0; 2613 PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT = 0; 2614 PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0; 2615 PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT = 0; 2616 PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT = 0; 2617 PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT = 0; 2618 PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT = 0; 2619 PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT = 0; 2620 PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT = 0; 2621 PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT = 0; 2622 PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV = 0; 2623 PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV = 0; 2624 PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV = 0; 2625 PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV = 0; 2626 PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV = 0; 2627 PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV = 0; 2628 PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV = 0; 2629 PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV = 0; 2630 PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV = 0; 2631 PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV = 0; 2632 2633 //=== VK_EXT_shader_module_identifier === 2634 PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT = 0; 2635 PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT = 0; 2636 2637 //=== VK_NV_optical_flow === 2638 PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV = 0; 2639 PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV = 0; 2640 PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0; 2641 PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0; 2642 2643 //=== VK_KHR_maintenance5 === 2644 PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR = 0; 2645 PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR = 0; 2646 PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR = 0; 2647 PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR = 0; 2648 2649 //=== VK_AMD_anti_lag === 2650 PFN_vkAntiLagUpdateAMD vkAntiLagUpdateAMD = 0; 2651 2652 //=== VK_EXT_shader_object === 2653 PFN_vkCreateShadersEXT vkCreateShadersEXT = 0; 2654 PFN_vkDestroyShaderEXT vkDestroyShaderEXT = 0; 2655 PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0; 2656 PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0; 2657 2658 //=== VK_KHR_pipeline_binary === 2659 PFN_vkCreatePipelineBinariesKHR vkCreatePipelineBinariesKHR = 0; 2660 PFN_vkDestroyPipelineBinaryKHR vkDestroyPipelineBinaryKHR = 0; 2661 PFN_vkGetPipelineKeyKHR vkGetPipelineKeyKHR = 0; 2662 PFN_vkGetPipelineBinaryDataKHR vkGetPipelineBinaryDataKHR = 0; 2663 PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR = 0; 2664 2665 //=== VK_QCOM_tile_properties === 2666 PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0; 2667 PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0; 2668 2669 //=== VK_NV_low_latency2 === 2670 PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0; 2671 PFN_vkLatencySleepNV vkLatencySleepNV = 0; 2672 PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0; 2673 PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0; 2674 PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0; 2675 2676 //=== VK_EXT_attachment_feedback_loop_dynamic_state === 2677 PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0; 2678 2679 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 2680 //=== VK_QNX_external_memory_screen_buffer === 2681 PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0; 2682 # else 2683 PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0; 2684 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 2685 2686 //=== VK_KHR_line_rasterization === 2687 PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0; 2688 2689 //=== VK_KHR_calibrated_timestamps === 2690 PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0; 2691 2692 //=== VK_KHR_maintenance6 === 2693 PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR = 0; 2694 PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR = 0; 2695 PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR = 0; 2696 PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR = 0; 2697 PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0; 2698 PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0; 2699 }; 2700 2701 //======================================== 2702 //=== RAII HANDLE forward declarations === 2703 //======================================== 2704 2705 //=== VK_VERSION_1_0 === 2706 class Instance; 2707 class PhysicalDevice; 2708 class Device; 2709 class Queue; 2710 class DeviceMemory; 2711 class Fence; 2712 class Semaphore; 2713 class Event; 2714 class QueryPool; 2715 class Buffer; 2716 class BufferView; 2717 class Image; 2718 class ImageView; 2719 class ShaderModule; 2720 class PipelineCache; 2721 class Pipeline; 2722 class PipelineLayout; 2723 class Sampler; 2724 class DescriptorPool; 2725 class DescriptorSet; 2726 class DescriptorSetLayout; 2727 class Framebuffer; 2728 class RenderPass; 2729 class CommandPool; 2730 class CommandBuffer; 2731 2732 //=== VK_VERSION_1_1 === 2733 class SamplerYcbcrConversion; 2734 class DescriptorUpdateTemplate; 2735 2736 //=== VK_VERSION_1_3 === 2737 class PrivateDataSlot; 2738 2739 //=== VK_KHR_surface === 2740 class SurfaceKHR; 2741 2742 //=== VK_KHR_swapchain === 2743 class SwapchainKHR; 2744 2745 //=== VK_KHR_display === 2746 class DisplayKHR; 2747 class DisplayModeKHR; 2748 2749 //=== VK_EXT_debug_report === 2750 class DebugReportCallbackEXT; 2751 2752 //=== VK_KHR_video_queue === 2753 class VideoSessionKHR; 2754 class VideoSessionParametersKHR; 2755 2756 //=== VK_NVX_binary_import === 2757 class CuModuleNVX; 2758 class CuFunctionNVX; 2759 2760 //=== VK_EXT_debug_utils === 2761 class DebugUtilsMessengerEXT; 2762 2763 //=== VK_KHR_acceleration_structure === 2764 class AccelerationStructureKHR; 2765 2766 //=== VK_EXT_validation_cache === 2767 class ValidationCacheEXT; 2768 2769 //=== VK_NV_ray_tracing === 2770 class AccelerationStructureNV; 2771 2772 //=== VK_INTEL_performance_query === 2773 class PerformanceConfigurationINTEL; 2774 2775 //=== VK_KHR_deferred_host_operations === 2776 class DeferredOperationKHR; 2777 2778 //=== VK_NV_device_generated_commands === 2779 class IndirectCommandsLayoutNV; 2780 2781 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 2782 //=== VK_NV_cuda_kernel_launch === 2783 class CudaModuleNV; 2784 class CudaFunctionNV; 2785 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 2786 2787 # if defined( VK_USE_PLATFORM_FUCHSIA ) 2788 //=== VK_FUCHSIA_buffer_collection === 2789 class BufferCollectionFUCHSIA; 2790 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 2791 2792 //=== VK_EXT_opacity_micromap === 2793 class MicromapEXT; 2794 2795 //=== VK_NV_optical_flow === 2796 class OpticalFlowSessionNV; 2797 2798 //=== VK_EXT_shader_object === 2799 class ShaderEXT; 2800 2801 //=== VK_KHR_pipeline_binary === 2802 class PipelineBinaryKHR; 2803 2804 //==================== 2805 //=== RAII HANDLES === 2806 //==================== 2807 2808 class Context 2809 { 2810 public: 2811 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL Context()2812 Context() 2813 : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher( 2814 m_dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" ) ) ) 2815 # else 2816 Context( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) 2817 : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher( getInstanceProcAddr ) ) 2818 # endif 2819 { 2820 } 2821 2822 ~Context() = default; 2823 2824 Context( Context const & ) = delete; Context(Context && rhs)2825 Context( Context && rhs ) VULKAN_HPP_NOEXCEPT 2826 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 2827 : m_dynamicLoader( std::move( rhs.m_dynamicLoader ) ) 2828 , m_dispatcher( rhs.m_dispatcher.release() ) 2829 # else 2830 : m_dispatcher( rhs.m_dispatcher.release() ) 2831 # endif 2832 { 2833 } 2834 Context & operator=( Context const & ) = delete; 2835 operator =(Context && rhs)2836 Context & operator=( Context && rhs ) VULKAN_HPP_NOEXCEPT 2837 { 2838 if ( this != &rhs ) 2839 { 2840 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 2841 m_dynamicLoader = std::move( rhs.m_dynamicLoader ); 2842 # endif 2843 m_dispatcher.reset( rhs.m_dispatcher.release() ); 2844 } 2845 return *this; 2846 } 2847 getDispatcher() const2848 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const 2849 { 2850 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 2851 return &*m_dispatcher; 2852 } 2853 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context & rhs)2854 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context & rhs ) 2855 { 2856 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 2857 std::swap( m_dynamicLoader, rhs.m_dynamicLoader ); 2858 # endif 2859 m_dispatcher.swap( rhs.m_dispatcher ); 2860 } 2861 2862 //=== VK_VERSION_1_0 === 2863 2864 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance>::Type 2865 createInstance( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo, 2866 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 2867 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 2868 2869 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> 2870 enumerateInstanceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 2871 2872 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateInstanceLayerProperties() const; 2873 2874 //=== VK_VERSION_1_1 === 2875 2876 VULKAN_HPP_NODISCARD uint32_t enumerateInstanceVersion() const; 2877 2878 private: 2879 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 2880 VULKAN_HPP_NAMESPACE::DynamicLoader m_dynamicLoader; 2881 # endif 2882 std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher> m_dispatcher; 2883 }; 2884 2885 class Instance 2886 { 2887 public: 2888 using CType = VkInstance; 2889 using CppType = VULKAN_HPP_NAMESPACE::Instance; 2890 2891 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance; 2892 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 2893 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance; 2894 2895 public: 2896 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)2897 Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context, 2898 VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo, 2899 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 2900 { 2901 *this = context.createInstance( createInfo, allocator ); 2902 } 2903 # endif 2904 Instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context,VkInstance instance,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)2905 Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context, 2906 VkInstance instance, 2907 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 2908 : m_instance( instance ), m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 2909 { 2910 m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher( context.getDispatcher()->vkGetInstanceProcAddr, 2911 static_cast<VkInstance>( m_instance ) ) ); 2912 } 2913 Instance(std::nullptr_t)2914 Instance( std::nullptr_t ) {} 2915 ~Instance()2916 ~Instance() 2917 { 2918 clear(); 2919 } 2920 2921 Instance() = delete; 2922 Instance( Instance const & ) = delete; 2923 Instance(Instance && rhs)2924 Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT 2925 : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) 2926 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 2927 , m_dispatcher( rhs.m_dispatcher.release() ) 2928 { 2929 } 2930 2931 Instance & operator=( Instance const & ) = delete; 2932 operator =(Instance && rhs)2933 Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT 2934 { 2935 if ( this != &rhs ) 2936 { 2937 std::swap( m_instance, rhs.m_instance ); 2938 std::swap( m_allocator, rhs.m_allocator ); 2939 std::swap( m_dispatcher, rhs.m_dispatcher ); 2940 } 2941 return *this; 2942 } 2943 operator *() const2944 VULKAN_HPP_NAMESPACE::Instance const & operator*() const VULKAN_HPP_NOEXCEPT 2945 { 2946 return m_instance; 2947 } 2948 operator VULKAN_HPP_NAMESPACE::Instance() const2949 operator VULKAN_HPP_NAMESPACE::Instance() const VULKAN_HPP_NOEXCEPT 2950 { 2951 return m_instance; 2952 } 2953 clear()2954 void clear() VULKAN_HPP_NOEXCEPT 2955 { 2956 if ( m_instance ) 2957 { 2958 getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 2959 } 2960 m_instance = nullptr; 2961 m_allocator = nullptr; 2962 m_dispatcher = nullptr; 2963 } 2964 release()2965 VULKAN_HPP_NAMESPACE::Instance release() 2966 { 2967 m_allocator = nullptr; 2968 m_dispatcher = nullptr; 2969 return VULKAN_HPP_NAMESPACE::exchange( m_instance, nullptr ); 2970 } 2971 getDispatcher() const2972 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 2973 { 2974 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 2975 return &*m_dispatcher; 2976 } 2977 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance & rhs)2978 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance & rhs ) VULKAN_HPP_NOEXCEPT 2979 { 2980 std::swap( m_instance, rhs.m_instance ); 2981 std::swap( m_allocator, rhs.m_allocator ); 2982 std::swap( m_dispatcher, rhs.m_dispatcher ); 2983 } 2984 2985 //=== VK_VERSION_1_0 === 2986 2987 VULKAN_HPP_NODISCARD 2988 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice>>::Type 2989 enumeratePhysicalDevices() const; 2990 2991 VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; 2992 2993 //=== VK_VERSION_1_1 === 2994 2995 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroups() const; 2996 2997 //=== VK_KHR_display === 2998 2999 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3000 createDisplayPlaneSurfaceKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo, 3001 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3002 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3003 3004 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 3005 //=== VK_KHR_xlib_surface === 3006 3007 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3008 createXlibSurfaceKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo, 3009 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3010 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3011 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 3012 3013 # if defined( VK_USE_PLATFORM_XCB_KHR ) 3014 //=== VK_KHR_xcb_surface === 3015 3016 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3017 createXcbSurfaceKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo, 3018 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3019 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3020 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 3021 3022 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 3023 //=== VK_KHR_wayland_surface === 3024 3025 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3026 createWaylandSurfaceKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo, 3027 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3028 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3029 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 3030 3031 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 3032 //=== VK_KHR_android_surface === 3033 3034 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3035 createAndroidSurfaceKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo, 3036 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3037 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3038 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 3039 3040 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3041 //=== VK_KHR_win32_surface === 3042 3043 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3044 createWin32SurfaceKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo, 3045 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3046 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3047 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3048 3049 //=== VK_EXT_debug_report === 3050 3051 VULKAN_HPP_NODISCARD 3052 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT>::Type 3053 createDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo, 3054 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3055 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3056 3057 void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, 3058 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, 3059 uint64_t object, 3060 size_t location, 3061 int32_t messageCode, 3062 const std::string & layerPrefix, 3063 const std::string & message ) const VULKAN_HPP_NOEXCEPT; 3064 3065 # if defined( VK_USE_PLATFORM_GGP ) 3066 //=== VK_GGP_stream_descriptor_surface === 3067 3068 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3069 createStreamDescriptorSurfaceGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, 3070 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3071 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3072 # endif /*VK_USE_PLATFORM_GGP*/ 3073 3074 # if defined( VK_USE_PLATFORM_VI_NN ) 3075 //=== VK_NN_vi_surface === 3076 3077 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3078 createViSurfaceNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, 3079 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3080 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3081 # endif /*VK_USE_PLATFORM_VI_NN*/ 3082 3083 //=== VK_KHR_device_group_creation === 3084 3085 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroupsKHR() const; 3086 3087 # if defined( VK_USE_PLATFORM_IOS_MVK ) 3088 //=== VK_MVK_ios_surface === 3089 3090 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3091 createIOSSurfaceMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo, 3092 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3093 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3094 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 3095 3096 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 3097 //=== VK_MVK_macos_surface === 3098 3099 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3100 createMacOSSurfaceMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo, 3101 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3102 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3103 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 3104 3105 //=== VK_EXT_debug_utils === 3106 3107 VULKAN_HPP_NODISCARD 3108 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT>::Type 3109 createDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo, 3110 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3111 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3112 3113 void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 3114 VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, 3115 const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT; 3116 3117 # if defined( VK_USE_PLATFORM_FUCHSIA ) 3118 //=== VK_FUCHSIA_imagepipe_surface === 3119 3120 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3121 createImagePipeSurfaceFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, 3122 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3123 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3124 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 3125 3126 # if defined( VK_USE_PLATFORM_METAL_EXT ) 3127 //=== VK_EXT_metal_surface === 3128 3129 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3130 createMetalSurfaceEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo, 3131 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3132 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3133 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 3134 3135 //=== VK_EXT_headless_surface === 3136 3137 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3138 createHeadlessSurfaceEXT( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo, 3139 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3140 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3141 3142 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 3143 //=== VK_EXT_directfb_surface === 3144 3145 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3146 createDirectFBSurfaceEXT( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo, 3147 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3148 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3149 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 3150 3151 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 3152 //=== VK_QNX_screen_surface === 3153 3154 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type 3155 createScreenSurfaceQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, 3156 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3157 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3158 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 3159 3160 private: 3161 VULKAN_HPP_NAMESPACE::Instance m_instance = {}; 3162 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 3163 std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher> m_dispatcher; 3164 }; 3165 3166 class PhysicalDevice 3167 { 3168 public: 3169 using CType = VkPhysicalDevice; 3170 using CppType = VULKAN_HPP_NAMESPACE::PhysicalDevice; 3171 3172 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice; 3173 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 3174 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice; 3175 3176 public: PhysicalDevice(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VkPhysicalDevice physicalDevice)3177 PhysicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VkPhysicalDevice physicalDevice ) 3178 : m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() ) 3179 { 3180 } 3181 PhysicalDevice(std::nullptr_t)3182 PhysicalDevice( std::nullptr_t ) {} 3183 ~PhysicalDevice()3184 ~PhysicalDevice() 3185 { 3186 clear(); 3187 } 3188 3189 PhysicalDevice() = delete; 3190 PhysicalDevice(PhysicalDevice const & rhs)3191 PhysicalDevice( PhysicalDevice const & rhs ) : m_physicalDevice( rhs.m_physicalDevice ), m_dispatcher( rhs.m_dispatcher ) {} 3192 PhysicalDevice(PhysicalDevice && rhs)3193 PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT 3194 : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) 3195 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 3196 { 3197 } 3198 operator =(PhysicalDevice const & rhs)3199 PhysicalDevice & operator=( PhysicalDevice const & rhs ) 3200 { 3201 m_physicalDevice = rhs.m_physicalDevice; 3202 m_dispatcher = rhs.m_dispatcher; 3203 return *this; 3204 } 3205 operator =(PhysicalDevice && rhs)3206 PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT 3207 { 3208 if ( this != &rhs ) 3209 { 3210 std::swap( m_physicalDevice, rhs.m_physicalDevice ); 3211 std::swap( m_dispatcher, rhs.m_dispatcher ); 3212 } 3213 return *this; 3214 } 3215 operator *() const3216 VULKAN_HPP_NAMESPACE::PhysicalDevice const & operator*() const VULKAN_HPP_NOEXCEPT 3217 { 3218 return m_physicalDevice; 3219 } 3220 operator VULKAN_HPP_NAMESPACE::PhysicalDevice() const3221 operator VULKAN_HPP_NAMESPACE::PhysicalDevice() const VULKAN_HPP_NOEXCEPT 3222 { 3223 return m_physicalDevice; 3224 } 3225 clear()3226 void clear() VULKAN_HPP_NOEXCEPT 3227 { 3228 m_physicalDevice = nullptr; 3229 m_dispatcher = nullptr; 3230 } 3231 release()3232 VULKAN_HPP_NAMESPACE::PhysicalDevice release() 3233 { 3234 m_dispatcher = nullptr; 3235 return VULKAN_HPP_NAMESPACE::exchange( m_physicalDevice, nullptr ); 3236 } 3237 getDispatcher() const3238 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 3239 { 3240 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 3241 return m_dispatcher; 3242 } 3243 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice & rhs)3244 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice & rhs ) VULKAN_HPP_NOEXCEPT 3245 { 3246 std::swap( m_physicalDevice, rhs.m_physicalDevice ); 3247 std::swap( m_dispatcher, rhs.m_dispatcher ); 3248 } 3249 3250 //=== VK_VERSION_1_0 === 3251 3252 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT; 3253 3254 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 3255 3256 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties 3257 getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, 3258 VULKAN_HPP_NAMESPACE::ImageType type, 3259 VULKAN_HPP_NAMESPACE::ImageTiling tiling, 3260 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 3261 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 3262 3263 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties() const VULKAN_HPP_NOEXCEPT; 3264 3265 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> getQueueFamilyProperties() const; 3266 3267 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties() const VULKAN_HPP_NOEXCEPT; 3268 3269 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device>::Type 3270 createDevice( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo, 3271 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3272 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3273 3274 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> 3275 enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 3276 3277 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateDeviceLayerProperties() const; 3278 3279 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> 3280 getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, 3281 VULKAN_HPP_NAMESPACE::ImageType type, 3282 VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, 3283 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 3284 VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const; 3285 3286 //=== VK_VERSION_1_1 === 3287 3288 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2() const VULKAN_HPP_NOEXCEPT; 3289 3290 template <typename X, typename Y, typename... Z> 3291 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFeatures2() const VULKAN_HPP_NOEXCEPT; 3292 3293 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2() const VULKAN_HPP_NOEXCEPT; 3294 3295 template <typename X, typename Y, typename... Z> 3296 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getProperties2() const VULKAN_HPP_NOEXCEPT; 3297 3298 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 3299 3300 template <typename X, typename Y, typename... Z> 3301 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3302 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 3303 3304 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2 3305 getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; 3306 3307 template <typename X, typename Y, typename... Z> 3308 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3309 getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; 3310 3311 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2() const; 3312 3313 template <typename StructureChain> 3314 VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2() const; 3315 3316 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; 3317 3318 template <typename X, typename Y, typename... Z> 3319 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; 3320 3321 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> 3322 getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const; 3323 3324 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties 3325 getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT; 3326 3327 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties 3328 getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT; 3329 3330 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties 3331 getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT; 3332 3333 //=== VK_VERSION_1_3 === 3334 3335 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> getToolProperties() const; 3336 3337 //=== VK_KHR_surface === 3338 3339 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 3340 3341 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 3342 3343 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> 3344 getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 3345 3346 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> 3347 getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 3348 3349 //=== VK_KHR_swapchain === 3350 3351 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Rect2D> getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 3352 3353 //=== VK_KHR_display === 3354 3355 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> getDisplayPropertiesKHR() const; 3356 3357 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> getDisplayPlanePropertiesKHR() const; 3358 3359 VULKAN_HPP_NODISCARD 3360 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>>::Type 3361 getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const; 3362 3363 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 3364 //=== VK_KHR_xlib_surface === 3365 3366 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 3367 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT; 3368 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 3369 3370 # if defined( VK_USE_PLATFORM_XCB_KHR ) 3371 //=== VK_KHR_xcb_surface === 3372 3373 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 3374 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT; 3375 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 3376 3377 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 3378 //=== VK_KHR_wayland_surface === 3379 3380 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, 3381 struct wl_display & display ) const VULKAN_HPP_NOEXCEPT; 3382 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 3383 3384 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3385 //=== VK_KHR_win32_surface === 3386 3387 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT; 3388 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3389 3390 //=== VK_KHR_video_queue === 3391 3392 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR 3393 getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const; 3394 3395 template <typename X, typename Y, typename... Z> 3396 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3397 getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const; 3398 3399 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> 3400 getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const; 3401 3402 //=== VK_NV_external_memory_capabilities === 3403 3404 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV getExternalImageFormatPropertiesNV( 3405 VULKAN_HPP_NAMESPACE::Format format, 3406 VULKAN_HPP_NAMESPACE::ImageType type, 3407 VULKAN_HPP_NAMESPACE::ImageTiling tiling, 3408 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 3409 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, 3410 VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 3411 3412 //=== VK_KHR_get_physical_device_properties2 === 3413 3414 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; 3415 3416 template <typename X, typename Y, typename... Z> 3417 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; 3418 3419 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2KHR() const VULKAN_HPP_NOEXCEPT; 3420 3421 template <typename X, typename Y, typename... Z> 3422 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getProperties2KHR() const VULKAN_HPP_NOEXCEPT; 3423 3424 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 3425 3426 template <typename X, typename Y, typename... Z> 3427 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3428 getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT; 3429 3430 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2 3431 getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; 3432 3433 template <typename X, typename Y, typename... Z> 3434 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3435 getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; 3436 3437 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2KHR() const; 3438 3439 template <typename StructureChain> 3440 VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2KHR() const; 3441 3442 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; 3443 3444 template <typename X, typename Y, typename... Z> 3445 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; 3446 3447 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> 3448 getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const; 3449 3450 //=== VK_KHR_external_memory_capabilities === 3451 3452 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties 3453 getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT; 3454 3455 //=== VK_KHR_external_semaphore_capabilities === 3456 3457 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties 3458 getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT; 3459 3460 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 3461 //=== VK_EXT_acquire_xlib_display === 3462 3463 void acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; 3464 3465 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type 3466 getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3467 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 3468 3469 //=== VK_EXT_display_surface_counter === 3470 3471 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 3472 3473 //=== VK_KHR_external_fence_capabilities === 3474 3475 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties 3476 getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT; 3477 3478 //=== VK_KHR_performance_query === 3479 3480 VULKAN_HPP_NODISCARD 3481 std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>> 3482 enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const; 3483 3484 VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR( 3485 const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT; 3486 3487 //=== VK_KHR_get_surface_capabilities2 === 3488 3489 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR 3490 getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 3491 3492 template <typename X, typename Y, typename... Z> 3493 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3494 getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 3495 3496 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> 3497 getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 3498 3499 template <typename StructureChain> 3500 VULKAN_HPP_NODISCARD std::vector<StructureChain> getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 3501 3502 //=== VK_KHR_get_display_properties2 === 3503 3504 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> getDisplayProperties2KHR() const; 3505 3506 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> getDisplayPlaneProperties2KHR() const; 3507 3508 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR 3509 getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const; 3510 3511 //=== VK_EXT_sample_locations === 3512 3513 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT 3514 getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT; 3515 3516 //=== VK_EXT_calibrated_timestamps === 3517 3518 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> getCalibrateableTimeDomainsEXT() const; 3519 3520 //=== VK_KHR_fragment_shading_rate === 3521 3522 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> getFragmentShadingRatesKHR() const; 3523 3524 //=== VK_EXT_tooling_info === 3525 3526 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> getToolPropertiesEXT() const; 3527 3528 //=== VK_NV_cooperative_matrix === 3529 3530 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> getCooperativeMatrixPropertiesNV() const; 3531 3532 //=== VK_NV_coverage_reduction_mode === 3533 3534 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> getSupportedFramebufferMixedSamplesCombinationsNV() const; 3535 3536 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3537 //=== VK_EXT_full_screen_exclusive === 3538 3539 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> 3540 getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 3541 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3542 3543 //=== VK_EXT_acquire_drm_display === 3544 3545 void acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; 3546 3547 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type 3548 getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3549 3550 //=== VK_KHR_video_encode_queue === 3551 3552 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR 3553 getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const; 3554 3555 template <typename X, typename Y, typename... Z> 3556 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3557 getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const; 3558 3559 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3560 //=== VK_NV_acquire_winrt_display === 3561 3562 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type 3563 getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3564 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3565 3566 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 3567 //=== VK_EXT_directfb_surface === 3568 3569 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, 3570 IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT; 3571 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 3572 3573 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 3574 //=== VK_QNX_screen_surface === 3575 3576 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, 3577 struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT; 3578 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 3579 3580 //=== VK_NV_optical_flow === 3581 3582 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> 3583 getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const; 3584 3585 //=== VK_KHR_cooperative_matrix === 3586 3587 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> getCooperativeMatrixPropertiesKHR() const; 3588 3589 //=== VK_KHR_calibrated_timestamps === 3590 3591 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> getCalibrateableTimeDomainsKHR() const; 3592 3593 private: 3594 VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; 3595 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 3596 }; 3597 3598 class PhysicalDevices : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> 3599 { 3600 public: 3601 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) PhysicalDevices(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance)3602 PhysicalDevices( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance ) 3603 { 3604 *this = instance.enumeratePhysicalDevices(); 3605 } 3606 # endif 3607 PhysicalDevices(std::nullptr_t)3608 PhysicalDevices( std::nullptr_t ) {} 3609 3610 PhysicalDevices() = delete; 3611 PhysicalDevices( PhysicalDevices const & ) = delete; 3612 PhysicalDevices( PhysicalDevices && rhs ) = default; 3613 PhysicalDevices & operator=( PhysicalDevices const & ) = delete; 3614 PhysicalDevices & operator=( PhysicalDevices && rhs ) = default; 3615 3616 private: PhysicalDevices(std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> && rhs)3617 PhysicalDevices( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> && rhs ) 3618 { 3619 std::swap( *this, rhs ); 3620 } 3621 }; 3622 3623 class Device 3624 { 3625 public: 3626 using CType = VkDevice; 3627 using CppType = VULKAN_HPP_NAMESPACE::Device; 3628 3629 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice; 3630 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 3631 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice; 3632 3633 public: 3634 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)3635 Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, 3636 VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo, 3637 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 3638 { 3639 *this = physicalDevice.createDevice( createInfo, allocator ); 3640 } 3641 # endif 3642 Device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,VkDevice device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)3643 Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, 3644 VkDevice device, 3645 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 3646 : m_device( device ), m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 3647 { 3648 m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr, 3649 static_cast<VkDevice>( m_device ) ) ); 3650 } 3651 Device(std::nullptr_t)3652 Device( std::nullptr_t ) {} 3653 ~Device()3654 ~Device() 3655 { 3656 clear(); 3657 } 3658 3659 Device() = delete; 3660 Device( Device const & ) = delete; 3661 Device(Device && rhs)3662 Device( Device && rhs ) VULKAN_HPP_NOEXCEPT 3663 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 3664 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 3665 , m_dispatcher( rhs.m_dispatcher.release() ) 3666 { 3667 } 3668 3669 Device & operator=( Device const & ) = delete; 3670 operator =(Device && rhs)3671 Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT 3672 { 3673 if ( this != &rhs ) 3674 { 3675 std::swap( m_device, rhs.m_device ); 3676 std::swap( m_allocator, rhs.m_allocator ); 3677 std::swap( m_dispatcher, rhs.m_dispatcher ); 3678 } 3679 return *this; 3680 } 3681 operator *() const3682 VULKAN_HPP_NAMESPACE::Device const & operator*() const VULKAN_HPP_NOEXCEPT 3683 { 3684 return m_device; 3685 } 3686 operator VULKAN_HPP_NAMESPACE::Device() const3687 operator VULKAN_HPP_NAMESPACE::Device() const VULKAN_HPP_NOEXCEPT 3688 { 3689 return m_device; 3690 } 3691 clear()3692 void clear() VULKAN_HPP_NOEXCEPT 3693 { 3694 if ( m_device ) 3695 { 3696 getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 3697 } 3698 m_device = nullptr; 3699 m_allocator = nullptr; 3700 m_dispatcher = nullptr; 3701 } 3702 release()3703 VULKAN_HPP_NAMESPACE::Device release() 3704 { 3705 m_allocator = nullptr; 3706 m_dispatcher = nullptr; 3707 return VULKAN_HPP_NAMESPACE::exchange( m_device, nullptr ); 3708 } 3709 getDispatcher() const3710 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 3711 { 3712 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 3713 return &*m_dispatcher; 3714 } 3715 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device & rhs)3716 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device & rhs ) VULKAN_HPP_NOEXCEPT 3717 { 3718 std::swap( m_device, rhs.m_device ); 3719 std::swap( m_allocator, rhs.m_allocator ); 3720 std::swap( m_dispatcher, rhs.m_dispatcher ); 3721 } 3722 3723 //=== VK_VERSION_1_0 === 3724 3725 VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; 3726 3727 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue>::Type 3728 getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3729 3730 void waitIdle() const; 3731 3732 VULKAN_HPP_NODISCARD 3733 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory>::Type 3734 allocateMemory( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo, 3735 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3736 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3737 3738 void flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const; 3739 3740 void invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const; 3741 3742 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type 3743 createFence( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo, 3744 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3745 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3746 3747 void resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const; 3748 3749 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, 3750 VULKAN_HPP_NAMESPACE::Bool32 waitAll, 3751 uint64_t timeout ) const; 3752 3753 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore>::Type 3754 createSemaphore( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo, 3755 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3756 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3757 3758 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event>::Type 3759 createEvent( VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo, 3760 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3761 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3762 3763 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool>::Type 3764 createQueryPool( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo, 3765 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3766 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3767 3768 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer>::Type 3769 createBuffer( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo, 3770 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3771 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3772 3773 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView>::Type 3774 createBufferView( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo, 3775 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3776 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3777 3778 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image>::Type 3779 createImage( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo, 3780 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3781 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3782 3783 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView>::Type 3784 createImageView( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo, 3785 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3786 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3787 3788 VULKAN_HPP_NODISCARD 3789 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule>::Type 3790 createShaderModule( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo, 3791 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3792 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3793 3794 VULKAN_HPP_NODISCARD 3795 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache>::Type 3796 createPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo, 3797 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3798 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3799 3800 VULKAN_HPP_NODISCARD 3801 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type 3802 createGraphicsPipelines( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 3803 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, 3804 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3805 3806 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type 3807 createGraphicsPipeline( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 3808 VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo, 3809 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3810 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3811 3812 VULKAN_HPP_NODISCARD 3813 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type 3814 createComputePipelines( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 3815 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, 3816 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 3817 3818 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type 3819 createComputePipeline( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 3820 VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo, 3821 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3822 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3823 3824 VULKAN_HPP_NODISCARD 3825 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout>::Type 3826 createPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo, 3827 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3828 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3829 3830 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler>::Type 3831 createSampler( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo, 3832 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3833 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3834 3835 VULKAN_HPP_NODISCARD 3836 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout>::Type 3837 createDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo, 3838 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3839 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3840 3841 VULKAN_HPP_NODISCARD 3842 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool>::Type 3843 createDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo, 3844 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3845 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3846 3847 VULKAN_HPP_NODISCARD 3848 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>>::Type 3849 allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const; 3850 3851 void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, 3852 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies ) const 3853 VULKAN_HPP_NOEXCEPT; 3854 3855 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer>::Type 3856 createFramebuffer( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo, 3857 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3858 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3859 3860 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type 3861 createRenderPass( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo, 3862 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3863 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3864 3865 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool>::Type 3866 createCommandPool( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo, 3867 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3868 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3869 3870 VULKAN_HPP_NODISCARD 3871 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>>::Type 3872 allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const; 3873 3874 //=== VK_VERSION_1_1 === 3875 3876 void bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const; 3877 3878 void bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const; 3879 3880 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags 3881 getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT; 3882 3883 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 3884 getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3885 3886 template <typename X, typename Y, typename... Z> 3887 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3888 getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3889 3890 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 3891 getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3892 3893 template <typename X, typename Y, typename... Z> 3894 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3895 getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 3896 3897 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 3898 getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const; 3899 3900 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue>::Type 3901 getQueue2( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3902 3903 VULKAN_HPP_NODISCARD 3904 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion>::Type 3905 createSamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 3906 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3907 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3908 3909 VULKAN_HPP_NODISCARD 3910 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate>::Type 3911 createDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 3912 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3913 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3914 3915 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport 3916 getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 3917 3918 template <typename X, typename Y, typename... Z> 3919 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3920 getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 3921 3922 //=== VK_VERSION_1_2 === 3923 3924 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type 3925 createRenderPass2( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 3926 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3927 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3928 3929 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const; 3930 3931 void signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const; 3932 3933 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress 3934 getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3935 3936 VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3937 3938 VULKAN_HPP_NODISCARD uint64_t 3939 getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 3940 3941 //=== VK_VERSION_1_3 === 3942 3943 VULKAN_HPP_NODISCARD 3944 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot>::Type 3945 createPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo, 3946 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 3947 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 3948 3949 void setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 3950 uint64_t objectHandle, 3951 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, 3952 uint64_t data ) const; 3953 3954 VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 3955 uint64_t objectHandle, 3956 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT; 3957 3958 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 3959 getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; 3960 3961 template <typename X, typename Y, typename... Z> 3962 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3963 getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; 3964 3965 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 3966 getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; 3967 3968 template <typename X, typename Y, typename... Z> 3969 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3970 getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; 3971 3972 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 3973 getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const; 3974 3975 //=== VK_VERSION_1_4 === 3976 3977 VULKAN_HPP_NODISCARD void * mapMemory2( const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo ) const; 3978 3979 void unmapMemory2( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo ) const; 3980 3981 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D 3982 getRenderingAreaGranularity( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT; 3983 3984 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 3985 getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; 3986 3987 template <typename X, typename Y, typename... Z> 3988 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 3989 getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; 3990 3991 void copyMemoryToImage( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo ) const; 3992 3993 void copyImageToMemory( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo ) const; 3994 3995 void copyImageToImage( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo ) const; 3996 3997 void transitionImageLayout( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions ) const; 3998 3999 //=== VK_KHR_swapchain === 4000 4001 VULKAN_HPP_NODISCARD 4002 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>::Type 4003 createSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 4004 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4005 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4006 4007 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR getGroupPresentCapabilitiesKHR() const; 4008 4009 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR 4010 getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; 4011 4012 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> 4013 acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo ) const; 4014 4015 //=== VK_KHR_display_swapchain === 4016 4017 VULKAN_HPP_NODISCARD 4018 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>>::Type 4019 createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, 4020 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 4021 4022 VULKAN_HPP_NODISCARD 4023 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>::Type 4024 createSharedSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 4025 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4026 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4027 4028 //=== VK_EXT_debug_marker === 4029 4030 void debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo ) const; 4031 4032 void debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo ) const; 4033 4034 //=== VK_KHR_video_queue === 4035 4036 VULKAN_HPP_NODISCARD 4037 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR>::Type 4038 createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, 4039 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4040 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4041 4042 VULKAN_HPP_NODISCARD 4043 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR>::Type 4044 createVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo, 4045 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4046 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4047 4048 //=== VK_NVX_binary_import === 4049 4050 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX>::Type 4051 createCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo, 4052 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4053 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4054 4055 VULKAN_HPP_NODISCARD 4056 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX>::Type 4057 createCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo, 4058 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4059 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4060 4061 //=== VK_NVX_image_view_handle === 4062 4063 VULKAN_HPP_NODISCARD uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT; 4064 4065 //=== VK_KHR_device_group === 4066 4067 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags 4068 getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT; 4069 4070 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4071 //=== VK_KHR_external_memory_win32 === 4072 4073 VULKAN_HPP_NODISCARD HANDLE getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const; 4074 4075 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR 4076 getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const; 4077 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4078 4079 //=== VK_KHR_external_memory_fd === 4080 4081 VULKAN_HPP_NODISCARD int getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo ) const; 4082 4083 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR 4084 getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd ) const; 4085 4086 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4087 //=== VK_KHR_external_semaphore_win32 === 4088 4089 void importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const; 4090 4091 VULKAN_HPP_NODISCARD HANDLE getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const; 4092 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4093 4094 //=== VK_KHR_external_semaphore_fd === 4095 4096 void importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const; 4097 4098 VULKAN_HPP_NODISCARD int getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo ) const; 4099 4100 //=== VK_KHR_descriptor_update_template === 4101 4102 VULKAN_HPP_NODISCARD 4103 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate>::Type 4104 createDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 4105 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4106 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4107 4108 void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, 4109 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator 4110 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 4111 4112 //=== VK_EXT_display_control === 4113 4114 void displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo ) const; 4115 4116 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type 4117 registerEventEXT( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo, 4118 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4119 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4120 4121 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type 4122 registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, 4123 VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo, 4124 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4125 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4126 4127 //=== VK_EXT_hdr_metadata === 4128 4129 void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, 4130 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const; 4131 4132 //=== VK_KHR_create_renderpass2 === 4133 4134 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type 4135 createRenderPass2KHR( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 4136 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4137 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4138 4139 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4140 //=== VK_KHR_external_fence_win32 === 4141 4142 void importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const; 4143 4144 VULKAN_HPP_NODISCARD HANDLE getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const; 4145 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4146 4147 //=== VK_KHR_external_fence_fd === 4148 4149 void importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo ) const; 4150 4151 VULKAN_HPP_NODISCARD int getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo ) const; 4152 4153 //=== VK_KHR_performance_query === 4154 4155 void acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info ) const; 4156 4157 void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT; 4158 4159 //=== VK_EXT_debug_utils === 4160 4161 void setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo ) const; 4162 4163 void setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo ) const; 4164 4165 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 4166 //=== VK_ANDROID_external_memory_android_hardware_buffer === 4167 4168 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID 4169 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const; 4170 4171 template <typename X, typename Y, typename... Z> 4172 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 4173 getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const; 4174 4175 VULKAN_HPP_NODISCARD struct AHardwareBuffer * 4176 getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info ) const; 4177 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 4178 4179 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4180 //=== VK_AMDX_shader_enqueue === 4181 4182 VULKAN_HPP_NODISCARD 4183 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type 4184 createExecutionGraphPipelinesAMDX( 4185 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 4186 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, 4187 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 4188 4189 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type 4190 createExecutionGraphPipelineAMDX( 4191 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 4192 VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & createInfo, 4193 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4194 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4195 4196 //=== VK_KHR_get_memory_requirements2 === 4197 4198 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 4199 getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 4200 4201 template <typename X, typename Y, typename... Z> 4202 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 4203 getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 4204 4205 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 4206 getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 4207 4208 template <typename X, typename Y, typename... Z> 4209 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 4210 getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; 4211 4212 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 4213 getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const; 4214 4215 //=== VK_KHR_acceleration_structure === 4216 4217 VULKAN_HPP_NODISCARD 4218 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR>::Type 4219 createAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo, 4220 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4221 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4222 4223 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR( 4224 VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 4225 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 4226 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) const; 4227 4228 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result 4229 copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 4230 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const; 4231 4232 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result 4233 copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 4234 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const; 4235 4236 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result 4237 copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 4238 const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const; 4239 4240 template <typename DataType> 4241 VULKAN_HPP_NODISCARD std::vector<DataType> writeAccelerationStructuresPropertiesKHR( 4242 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 4243 VULKAN_HPP_NAMESPACE::QueryType queryType, 4244 size_t dataSize, 4245 size_t stride ) const; 4246 4247 template <typename DataType> 4248 VULKAN_HPP_NODISCARD DataType writeAccelerationStructuresPropertyKHR( 4249 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 4250 VULKAN_HPP_NAMESPACE::QueryType queryType, 4251 size_t stride ) const; 4252 4253 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress 4254 getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; 4255 4256 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR 4257 getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT; 4258 4259 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR( 4260 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, 4261 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo, 4262 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 4263 4264 //=== VK_KHR_ray_tracing_pipeline === 4265 4266 VULKAN_HPP_NODISCARD 4267 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type 4268 createRayTracingPipelinesKHR( 4269 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 4270 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 4271 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, 4272 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 4273 4274 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type 4275 createRayTracingPipelineKHR( 4276 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 4277 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 4278 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo, 4279 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4280 4281 //=== VK_KHR_sampler_ycbcr_conversion === 4282 4283 VULKAN_HPP_NODISCARD 4284 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion>::Type 4285 createSamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 4286 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4287 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4288 4289 void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, 4290 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator 4291 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 4292 4293 //=== VK_KHR_bind_memory2 === 4294 4295 void bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const; 4296 4297 void bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const; 4298 4299 //=== VK_EXT_validation_cache === 4300 4301 VULKAN_HPP_NODISCARD 4302 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT>::Type 4303 createValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo, 4304 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4305 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4306 4307 //=== VK_NV_ray_tracing === 4308 4309 VULKAN_HPP_NODISCARD 4310 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV>::Type 4311 createAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo, 4312 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4313 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4314 4315 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( 4316 const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; 4317 4318 template <typename X, typename Y, typename... Z> 4319 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV( 4320 const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; 4321 4322 void bindAccelerationStructureMemoryNV( 4323 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const; 4324 4325 VULKAN_HPP_NODISCARD 4326 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type 4327 createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 4328 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, 4329 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 4330 4331 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type 4332 createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 4333 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo, 4334 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4335 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4336 4337 //=== VK_KHR_maintenance3 === 4338 4339 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport 4340 getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 4341 4342 template <typename X, typename Y, typename... Z> 4343 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 4344 getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 4345 4346 //=== VK_EXT_external_memory_host === 4347 4348 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT 4349 getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const; 4350 4351 //=== VK_EXT_calibrated_timestamps === 4352 4353 VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t> 4354 getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const; 4355 4356 VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t> 4357 getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const; 4358 4359 //=== VK_KHR_timeline_semaphore === 4360 4361 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const; 4362 4363 void signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const; 4364 4365 //=== VK_INTEL_performance_query === 4366 4367 void initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo ) const; 4368 4369 void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT; 4370 4371 VULKAN_HPP_NODISCARD 4372 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL>::Type 4373 acquirePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const 4374 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4375 4376 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PerformanceValueINTEL 4377 getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const; 4378 4379 //=== VK_EXT_buffer_device_address === 4380 4381 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress 4382 getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 4383 4384 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4385 //=== VK_EXT_full_screen_exclusive === 4386 4387 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR 4388 getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; 4389 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4390 4391 //=== VK_KHR_buffer_device_address === 4392 4393 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress 4394 getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 4395 4396 VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 4397 4398 VULKAN_HPP_NODISCARD uint64_t 4399 getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; 4400 4401 //=== VK_KHR_deferred_host_operations === 4402 4403 VULKAN_HPP_NODISCARD 4404 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR>::Type 4405 createDeferredOperationKHR( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4406 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4407 4408 //=== VK_KHR_pipeline_executable_properties === 4409 4410 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> 4411 getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo ) const; 4412 4413 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> 4414 getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const; 4415 4416 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> 4417 getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const; 4418 4419 //=== VK_EXT_host_image_copy === 4420 4421 void copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo ) const; 4422 4423 void copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo ) const; 4424 4425 void copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo ) const; 4426 4427 void transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions ) const; 4428 4429 //=== VK_KHR_map_memory2 === 4430 4431 VULKAN_HPP_NODISCARD void * mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo ) const; 4432 4433 void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo ) const; 4434 4435 //=== VK_EXT_swapchain_maintenance1 === 4436 4437 void releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo ) const; 4438 4439 //=== VK_NV_device_generated_commands === 4440 4441 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 4442 getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; 4443 4444 template <typename X, typename Y, typename... Z> 4445 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 4446 getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; 4447 4448 VULKAN_HPP_NODISCARD 4449 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV>::Type 4450 createIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo, 4451 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4452 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4453 4454 //=== VK_EXT_private_data === 4455 4456 VULKAN_HPP_NODISCARD 4457 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot>::Type 4458 createPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo, 4459 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4460 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4461 4462 void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, 4463 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator 4464 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 4465 4466 void setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 4467 uint64_t objectHandle, 4468 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, 4469 uint64_t data ) const; 4470 4471 VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 4472 uint64_t objectHandle, 4473 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT; 4474 4475 //=== VK_KHR_video_encode_queue === 4476 4477 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t>> 4478 getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const; 4479 4480 template <typename X, typename Y, typename... Z> 4481 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t>> 4482 getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const; 4483 4484 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 4485 //=== VK_NV_cuda_kernel_launch === 4486 4487 VULKAN_HPP_NODISCARD 4488 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV>::Type 4489 createCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & createInfo, 4490 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4491 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4492 4493 VULKAN_HPP_NODISCARD 4494 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV>::Type 4495 createCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & createInfo, 4496 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4497 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4498 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 4499 4500 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4501 //=== VK_EXT_metal_objects === 4502 4503 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT; 4504 4505 template <typename X, typename Y, typename... Z> 4506 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT; 4507 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4508 4509 //=== VK_EXT_descriptor_buffer === 4510 4511 void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT; 4512 4513 template <typename DescriptorType> 4514 VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT; 4515 4516 template <typename DataType> 4517 VULKAN_HPP_NODISCARD DataType getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info ) const; 4518 4519 template <typename DataType> 4520 VULKAN_HPP_NODISCARD DataType getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info ) const; 4521 4522 template <typename DataType> 4523 VULKAN_HPP_NODISCARD DataType 4524 getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info ) const; 4525 4526 template <typename DataType> 4527 VULKAN_HPP_NODISCARD DataType getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info ) const; 4528 4529 template <typename DataType> 4530 VULKAN_HPP_NODISCARD DataType 4531 getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const; 4532 4533 //=== VK_EXT_device_fault === 4534 template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> 4535 VULKAN_HPP_NODISCARD Result getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts, 4536 VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT * pFaultInfo, 4537 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 4538 # if defined( VK_USE_PLATFORM_FUCHSIA ) 4539 //=== VK_FUCHSIA_external_memory === 4540 4541 VULKAN_HPP_NODISCARD zx_handle_t getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const; 4542 4543 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA 4544 getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const; 4545 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 4546 4547 # if defined( VK_USE_PLATFORM_FUCHSIA ) 4548 //=== VK_FUCHSIA_external_semaphore === 4549 4550 void importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const; 4551 4552 VULKAN_HPP_NODISCARD zx_handle_t 4553 getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const; 4554 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 4555 4556 # if defined( VK_USE_PLATFORM_FUCHSIA ) 4557 //=== VK_FUCHSIA_buffer_collection === 4558 4559 VULKAN_HPP_NODISCARD 4560 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA>::Type 4561 createBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo, 4562 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4563 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4564 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 4565 4566 //=== VK_NV_external_memory_rdma === 4567 4568 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RemoteAddressNV 4569 getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const; 4570 4571 //=== VK_EXT_pipeline_properties === 4572 4573 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BaseOutStructure getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo ) const; 4574 4575 //=== VK_EXT_opacity_micromap === 4576 4577 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT>::Type 4578 createMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo, 4579 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4580 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4581 4582 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result 4583 buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 4584 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos ) const; 4585 4586 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 4587 const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const; 4588 4589 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 4590 const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const; 4591 4592 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 4593 const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const; 4594 4595 template <typename DataType> 4596 VULKAN_HPP_NODISCARD std::vector<DataType> 4597 writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, 4598 VULKAN_HPP_NAMESPACE::QueryType queryType, 4599 size_t dataSize, 4600 size_t stride ) const; 4601 4602 template <typename DataType> 4603 VULKAN_HPP_NODISCARD DataType writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, 4604 VULKAN_HPP_NAMESPACE::QueryType queryType, 4605 size_t stride ) const; 4606 4607 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR 4608 getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT; 4609 4610 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT 4611 getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, 4612 const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo ) const VULKAN_HPP_NOEXCEPT; 4613 4614 //=== VK_KHR_maintenance4 === 4615 4616 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 4617 getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; 4618 4619 template <typename X, typename Y, typename... Z> 4620 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 4621 getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; 4622 4623 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 4624 getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; 4625 4626 template <typename X, typename Y, typename... Z> 4627 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 4628 getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; 4629 4630 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> 4631 getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const; 4632 4633 //=== VK_VALVE_descriptor_set_host_mapping === 4634 4635 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE( 4636 const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference ) const VULKAN_HPP_NOEXCEPT; 4637 4638 //=== VK_NV_device_generated_commands_compute === 4639 4640 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 4641 getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 4642 4643 template <typename X, typename Y, typename... Z> 4644 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 4645 getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 4646 4647 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress 4648 getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info ) const VULKAN_HPP_NOEXCEPT; 4649 4650 //=== VK_EXT_shader_module_identifier === 4651 4652 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT 4653 getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; 4654 4655 //=== VK_NV_optical_flow === 4656 4657 VULKAN_HPP_NODISCARD 4658 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV>::Type 4659 createOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo, 4660 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4661 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4662 4663 //=== VK_KHR_maintenance5 === 4664 4665 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D 4666 getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT; 4667 4668 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 4669 getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; 4670 4671 template <typename X, typename Y, typename... Z> 4672 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 4673 getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; 4674 4675 //=== VK_AMD_anti_lag === 4676 4677 void antiLagUpdateAMD( const VULKAN_HPP_NAMESPACE::AntiLagDataAMD & data ) const VULKAN_HPP_NOEXCEPT; 4678 4679 //=== VK_EXT_shader_object === 4680 4681 VULKAN_HPP_NODISCARD 4682 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT>>::Type 4683 createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, 4684 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 4685 4686 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT>::Type 4687 createShaderEXT( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo, 4688 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const 4689 VULKAN_HPP_RAII_CREATE_NOEXCEPT; 4690 4691 //=== VK_KHR_pipeline_binary === 4692 4693 VULKAN_HPP_NODISCARD 4694 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR>>::Type 4695 createPipelineBinariesKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & createInfo, 4696 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const; 4697 4698 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR getPipelineKeyKHR( 4699 Optional<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> pipelineCreateInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 4700 4701 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t>> 4702 getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info ) const; 4703 4704 void releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR & info, 4705 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator 4706 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 4707 4708 //=== VK_QCOM_tile_properties === 4709 4710 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM 4711 getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT; 4712 4713 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 4714 //=== VK_QNX_external_memory_screen_buffer === 4715 4716 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const; 4717 4718 template <typename X, typename Y, typename... Z> 4719 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const; 4720 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 4721 4722 //=== VK_KHR_calibrated_timestamps === 4723 4724 VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t> 4725 getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const; 4726 4727 VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t> 4728 getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const; 4729 4730 private: 4731 VULKAN_HPP_NAMESPACE::Device m_device = {}; 4732 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 4733 std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher> m_dispatcher; 4734 }; 4735 4736 class AccelerationStructureKHR 4737 { 4738 public: 4739 using CType = VkAccelerationStructureKHR; 4740 using CppType = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR; 4741 4742 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR; 4743 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 4744 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR; 4745 4746 public: 4747 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)4748 AccelerationStructureKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4749 VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo, 4750 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4751 { 4752 *this = device.createAccelerationStructureKHR( createInfo, allocator ); 4753 } 4754 # endif 4755 AccelerationStructureKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkAccelerationStructureKHR accelerationStructure,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4756 AccelerationStructureKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4757 VkAccelerationStructureKHR accelerationStructure, 4758 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4759 : m_device( device ) 4760 , m_accelerationStructure( accelerationStructure ) 4761 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4762 , m_dispatcher( device.getDispatcher() ) 4763 { 4764 } 4765 AccelerationStructureKHR(std::nullptr_t)4766 AccelerationStructureKHR( std::nullptr_t ) {} 4767 ~AccelerationStructureKHR()4768 ~AccelerationStructureKHR() 4769 { 4770 clear(); 4771 } 4772 4773 AccelerationStructureKHR() = delete; 4774 AccelerationStructureKHR( AccelerationStructureKHR const & ) = delete; 4775 AccelerationStructureKHR(AccelerationStructureKHR && rhs)4776 AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT 4777 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 4778 , m_accelerationStructure( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) ) 4779 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 4780 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 4781 { 4782 } 4783 4784 AccelerationStructureKHR & operator=( AccelerationStructureKHR const & ) = delete; 4785 operator =(AccelerationStructureKHR && rhs)4786 AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT 4787 { 4788 if ( this != &rhs ) 4789 { 4790 std::swap( m_device, rhs.m_device ); 4791 std::swap( m_accelerationStructure, rhs.m_accelerationStructure ); 4792 std::swap( m_allocator, rhs.m_allocator ); 4793 std::swap( m_dispatcher, rhs.m_dispatcher ); 4794 } 4795 return *this; 4796 } 4797 operator *() const4798 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const VULKAN_HPP_NOEXCEPT 4799 { 4800 return m_accelerationStructure; 4801 } 4802 operator VULKAN_HPP_NAMESPACE::AccelerationStructureKHR() const4803 operator VULKAN_HPP_NAMESPACE::AccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT 4804 { 4805 return m_accelerationStructure; 4806 } 4807 clear()4808 void clear() VULKAN_HPP_NOEXCEPT 4809 { 4810 if ( m_accelerationStructure ) 4811 { 4812 getDispatcher()->vkDestroyAccelerationStructureKHR( static_cast<VkDevice>( m_device ), 4813 static_cast<VkAccelerationStructureKHR>( m_accelerationStructure ), 4814 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4815 } 4816 m_device = nullptr; 4817 m_accelerationStructure = nullptr; 4818 m_allocator = nullptr; 4819 m_dispatcher = nullptr; 4820 } 4821 release()4822 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR release() 4823 { 4824 m_device = nullptr; 4825 m_allocator = nullptr; 4826 m_dispatcher = nullptr; 4827 return VULKAN_HPP_NAMESPACE::exchange( m_accelerationStructure, nullptr ); 4828 } 4829 getDevice() const4830 VULKAN_HPP_NAMESPACE::Device getDevice() const 4831 { 4832 return m_device; 4833 } 4834 getDispatcher() const4835 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 4836 { 4837 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 4838 return m_dispatcher; 4839 } 4840 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR & rhs)4841 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR & rhs ) VULKAN_HPP_NOEXCEPT 4842 { 4843 std::swap( m_device, rhs.m_device ); 4844 std::swap( m_accelerationStructure, rhs.m_accelerationStructure ); 4845 std::swap( m_allocator, rhs.m_allocator ); 4846 std::swap( m_dispatcher, rhs.m_dispatcher ); 4847 } 4848 4849 private: 4850 VULKAN_HPP_NAMESPACE::Device m_device = {}; 4851 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructure = {}; 4852 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 4853 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 4854 }; 4855 4856 class AccelerationStructureNV 4857 { 4858 public: 4859 using CType = VkAccelerationStructureNV; 4860 using CppType = VULKAN_HPP_NAMESPACE::AccelerationStructureNV; 4861 4862 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV; 4863 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 4864 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV; 4865 4866 public: 4867 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)4868 AccelerationStructureNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4869 VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo, 4870 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4871 { 4872 *this = device.createAccelerationStructureNV( createInfo, allocator ); 4873 } 4874 # endif 4875 AccelerationStructureNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkAccelerationStructureNV accelerationStructure,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)4876 AccelerationStructureNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4877 VkAccelerationStructureNV accelerationStructure, 4878 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4879 : m_device( device ) 4880 , m_accelerationStructure( accelerationStructure ) 4881 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 4882 , m_dispatcher( device.getDispatcher() ) 4883 { 4884 } 4885 AccelerationStructureNV(std::nullptr_t)4886 AccelerationStructureNV( std::nullptr_t ) {} 4887 ~AccelerationStructureNV()4888 ~AccelerationStructureNV() 4889 { 4890 clear(); 4891 } 4892 4893 AccelerationStructureNV() = delete; 4894 AccelerationStructureNV( AccelerationStructureNV const & ) = delete; 4895 AccelerationStructureNV(AccelerationStructureNV && rhs)4896 AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT 4897 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 4898 , m_accelerationStructure( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) ) 4899 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 4900 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 4901 { 4902 } 4903 4904 AccelerationStructureNV & operator=( AccelerationStructureNV const & ) = delete; 4905 operator =(AccelerationStructureNV && rhs)4906 AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT 4907 { 4908 if ( this != &rhs ) 4909 { 4910 std::swap( m_device, rhs.m_device ); 4911 std::swap( m_accelerationStructure, rhs.m_accelerationStructure ); 4912 std::swap( m_allocator, rhs.m_allocator ); 4913 std::swap( m_dispatcher, rhs.m_dispatcher ); 4914 } 4915 return *this; 4916 } 4917 operator *() const4918 VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & operator*() const VULKAN_HPP_NOEXCEPT 4919 { 4920 return m_accelerationStructure; 4921 } 4922 operator VULKAN_HPP_NAMESPACE::AccelerationStructureNV() const4923 operator VULKAN_HPP_NAMESPACE::AccelerationStructureNV() const VULKAN_HPP_NOEXCEPT 4924 { 4925 return m_accelerationStructure; 4926 } 4927 clear()4928 void clear() VULKAN_HPP_NOEXCEPT 4929 { 4930 if ( m_accelerationStructure ) 4931 { 4932 getDispatcher()->vkDestroyAccelerationStructureNV( static_cast<VkDevice>( m_device ), 4933 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ), 4934 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 4935 } 4936 m_device = nullptr; 4937 m_accelerationStructure = nullptr; 4938 m_allocator = nullptr; 4939 m_dispatcher = nullptr; 4940 } 4941 release()4942 VULKAN_HPP_NAMESPACE::AccelerationStructureNV release() 4943 { 4944 m_device = nullptr; 4945 m_allocator = nullptr; 4946 m_dispatcher = nullptr; 4947 return VULKAN_HPP_NAMESPACE::exchange( m_accelerationStructure, nullptr ); 4948 } 4949 getDevice() const4950 VULKAN_HPP_NAMESPACE::Device getDevice() const 4951 { 4952 return m_device; 4953 } 4954 getDispatcher() const4955 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 4956 { 4957 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 4958 return m_dispatcher; 4959 } 4960 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV & rhs)4961 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV & rhs ) VULKAN_HPP_NOEXCEPT 4962 { 4963 std::swap( m_device, rhs.m_device ); 4964 std::swap( m_accelerationStructure, rhs.m_accelerationStructure ); 4965 std::swap( m_allocator, rhs.m_allocator ); 4966 std::swap( m_dispatcher, rhs.m_dispatcher ); 4967 } 4968 4969 //=== VK_NV_ray_tracing === 4970 4971 template <typename DataType> 4972 VULKAN_HPP_NODISCARD std::vector<DataType> getHandle( size_t dataSize ) const; 4973 4974 template <typename DataType> 4975 VULKAN_HPP_NODISCARD DataType getHandle() const; 4976 4977 private: 4978 VULKAN_HPP_NAMESPACE::Device m_device = {}; 4979 VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructure = {}; 4980 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 4981 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 4982 }; 4983 4984 class Buffer 4985 { 4986 public: 4987 using CType = VkBuffer; 4988 using CppType = VULKAN_HPP_NAMESPACE::Buffer; 4989 4990 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer; 4991 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 4992 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer; 4993 4994 public: 4995 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)4996 Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 4997 VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo, 4998 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 4999 { 5000 *this = device.createBuffer( createInfo, allocator ); 5001 } 5002 # endif 5003 Buffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkBuffer buffer,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5004 Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5005 VkBuffer buffer, 5006 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5007 : m_device( device ) 5008 , m_buffer( buffer ) 5009 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5010 , m_dispatcher( device.getDispatcher() ) 5011 { 5012 } 5013 Buffer(std::nullptr_t)5014 Buffer( std::nullptr_t ) {} 5015 ~Buffer()5016 ~Buffer() 5017 { 5018 clear(); 5019 } 5020 5021 Buffer() = delete; 5022 Buffer( Buffer const & ) = delete; 5023 Buffer(Buffer && rhs)5024 Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT 5025 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 5026 , m_buffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_buffer, {} ) ) 5027 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5028 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5029 { 5030 } 5031 5032 Buffer & operator=( Buffer const & ) = delete; 5033 operator =(Buffer && rhs)5034 Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT 5035 { 5036 if ( this != &rhs ) 5037 { 5038 std::swap( m_device, rhs.m_device ); 5039 std::swap( m_buffer, rhs.m_buffer ); 5040 std::swap( m_allocator, rhs.m_allocator ); 5041 std::swap( m_dispatcher, rhs.m_dispatcher ); 5042 } 5043 return *this; 5044 } 5045 operator *() const5046 VULKAN_HPP_NAMESPACE::Buffer const & operator*() const VULKAN_HPP_NOEXCEPT 5047 { 5048 return m_buffer; 5049 } 5050 operator VULKAN_HPP_NAMESPACE::Buffer() const5051 operator VULKAN_HPP_NAMESPACE::Buffer() const VULKAN_HPP_NOEXCEPT 5052 { 5053 return m_buffer; 5054 } 5055 clear()5056 void clear() VULKAN_HPP_NOEXCEPT 5057 { 5058 if ( m_buffer ) 5059 { 5060 getDispatcher()->vkDestroyBuffer( 5061 static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( m_buffer ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5062 } 5063 m_device = nullptr; 5064 m_buffer = nullptr; 5065 m_allocator = nullptr; 5066 m_dispatcher = nullptr; 5067 } 5068 release()5069 VULKAN_HPP_NAMESPACE::Buffer release() 5070 { 5071 m_device = nullptr; 5072 m_allocator = nullptr; 5073 m_dispatcher = nullptr; 5074 return VULKAN_HPP_NAMESPACE::exchange( m_buffer, nullptr ); 5075 } 5076 getDevice() const5077 VULKAN_HPP_NAMESPACE::Device getDevice() const 5078 { 5079 return m_device; 5080 } 5081 getDispatcher() const5082 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 5083 { 5084 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5085 return m_dispatcher; 5086 } 5087 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer & rhs)5088 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer & rhs ) VULKAN_HPP_NOEXCEPT 5089 { 5090 std::swap( m_device, rhs.m_device ); 5091 std::swap( m_buffer, rhs.m_buffer ); 5092 std::swap( m_allocator, rhs.m_allocator ); 5093 std::swap( m_dispatcher, rhs.m_dispatcher ); 5094 } 5095 5096 //=== VK_VERSION_1_0 === 5097 5098 void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const; 5099 5100 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; 5101 5102 private: 5103 VULKAN_HPP_NAMESPACE::Device m_device = {}; 5104 VULKAN_HPP_NAMESPACE::Buffer m_buffer = {}; 5105 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 5106 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 5107 }; 5108 5109 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5110 class BufferCollectionFUCHSIA 5111 { 5112 public: 5113 using CType = VkBufferCollectionFUCHSIA; 5114 using CppType = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA; 5115 5116 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA; 5117 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5118 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA; 5119 5120 public: 5121 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)5122 BufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5123 VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo, 5124 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5125 { 5126 *this = device.createBufferCollectionFUCHSIA( createInfo, allocator ); 5127 } 5128 # endif 5129 BufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkBufferCollectionFUCHSIA collection,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5130 BufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5131 VkBufferCollectionFUCHSIA collection, 5132 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5133 : m_device( device ) 5134 , m_collection( collection ) 5135 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5136 , m_dispatcher( device.getDispatcher() ) 5137 { 5138 } 5139 BufferCollectionFUCHSIA(std::nullptr_t)5140 BufferCollectionFUCHSIA( std::nullptr_t ) {} 5141 ~BufferCollectionFUCHSIA()5142 ~BufferCollectionFUCHSIA() 5143 { 5144 clear(); 5145 } 5146 5147 BufferCollectionFUCHSIA() = delete; 5148 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & ) = delete; 5149 BufferCollectionFUCHSIA(BufferCollectionFUCHSIA && rhs)5150 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT 5151 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 5152 , m_collection( VULKAN_HPP_NAMESPACE::exchange( rhs.m_collection, {} ) ) 5153 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5154 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5155 { 5156 } 5157 5158 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete; 5159 operator =(BufferCollectionFUCHSIA && rhs)5160 BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT 5161 { 5162 if ( this != &rhs ) 5163 { 5164 std::swap( m_device, rhs.m_device ); 5165 std::swap( m_collection, rhs.m_collection ); 5166 std::swap( m_allocator, rhs.m_allocator ); 5167 std::swap( m_dispatcher, rhs.m_dispatcher ); 5168 } 5169 return *this; 5170 } 5171 operator *() const5172 VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & operator*() const VULKAN_HPP_NOEXCEPT 5173 { 5174 return m_collection; 5175 } 5176 operator VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA() const5177 operator VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT 5178 { 5179 return m_collection; 5180 } 5181 clear()5182 void clear() VULKAN_HPP_NOEXCEPT 5183 { 5184 if ( m_collection ) 5185 { 5186 getDispatcher()->vkDestroyBufferCollectionFUCHSIA( static_cast<VkDevice>( m_device ), 5187 static_cast<VkBufferCollectionFUCHSIA>( m_collection ), 5188 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5189 } 5190 m_device = nullptr; 5191 m_collection = nullptr; 5192 m_allocator = nullptr; 5193 m_dispatcher = nullptr; 5194 } 5195 release()5196 VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA release() 5197 { 5198 m_device = nullptr; 5199 m_allocator = nullptr; 5200 m_dispatcher = nullptr; 5201 return VULKAN_HPP_NAMESPACE::exchange( m_collection, nullptr ); 5202 } 5203 getDevice() const5204 VULKAN_HPP_NAMESPACE::Device getDevice() const 5205 { 5206 return m_device; 5207 } 5208 getDispatcher() const5209 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 5210 { 5211 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5212 return m_dispatcher; 5213 } 5214 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA & rhs)5215 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA & rhs ) VULKAN_HPP_NOEXCEPT 5216 { 5217 std::swap( m_device, rhs.m_device ); 5218 std::swap( m_collection, rhs.m_collection ); 5219 std::swap( m_allocator, rhs.m_allocator ); 5220 std::swap( m_dispatcher, rhs.m_dispatcher ); 5221 } 5222 5223 //=== VK_FUCHSIA_buffer_collection === 5224 5225 void setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const; 5226 5227 void setBufferConstraints( const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const; 5228 5229 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties() const; 5230 5231 private: 5232 VULKAN_HPP_NAMESPACE::Device m_device = {}; 5233 VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_collection = {}; 5234 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 5235 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 5236 }; 5237 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5238 5239 class BufferView 5240 { 5241 public: 5242 using CType = VkBufferView; 5243 using CppType = VULKAN_HPP_NAMESPACE::BufferView; 5244 5245 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView; 5246 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5247 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView; 5248 5249 public: 5250 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)5251 BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5252 VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo, 5253 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5254 { 5255 *this = device.createBufferView( createInfo, allocator ); 5256 } 5257 # endif 5258 BufferView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkBufferView bufferView,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5259 BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5260 VkBufferView bufferView, 5261 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5262 : m_device( device ) 5263 , m_bufferView( bufferView ) 5264 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5265 , m_dispatcher( device.getDispatcher() ) 5266 { 5267 } 5268 BufferView(std::nullptr_t)5269 BufferView( std::nullptr_t ) {} 5270 ~BufferView()5271 ~BufferView() 5272 { 5273 clear(); 5274 } 5275 5276 BufferView() = delete; 5277 BufferView( BufferView const & ) = delete; 5278 BufferView(BufferView && rhs)5279 BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT 5280 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 5281 , m_bufferView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferView, {} ) ) 5282 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5283 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5284 { 5285 } 5286 5287 BufferView & operator=( BufferView const & ) = delete; 5288 operator =(BufferView && rhs)5289 BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT 5290 { 5291 if ( this != &rhs ) 5292 { 5293 std::swap( m_device, rhs.m_device ); 5294 std::swap( m_bufferView, rhs.m_bufferView ); 5295 std::swap( m_allocator, rhs.m_allocator ); 5296 std::swap( m_dispatcher, rhs.m_dispatcher ); 5297 } 5298 return *this; 5299 } 5300 operator *() const5301 VULKAN_HPP_NAMESPACE::BufferView const & operator*() const VULKAN_HPP_NOEXCEPT 5302 { 5303 return m_bufferView; 5304 } 5305 operator VULKAN_HPP_NAMESPACE::BufferView() const5306 operator VULKAN_HPP_NAMESPACE::BufferView() const VULKAN_HPP_NOEXCEPT 5307 { 5308 return m_bufferView; 5309 } 5310 clear()5311 void clear() VULKAN_HPP_NOEXCEPT 5312 { 5313 if ( m_bufferView ) 5314 { 5315 getDispatcher()->vkDestroyBufferView( 5316 static_cast<VkDevice>( m_device ), static_cast<VkBufferView>( m_bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5317 } 5318 m_device = nullptr; 5319 m_bufferView = nullptr; 5320 m_allocator = nullptr; 5321 m_dispatcher = nullptr; 5322 } 5323 release()5324 VULKAN_HPP_NAMESPACE::BufferView release() 5325 { 5326 m_device = nullptr; 5327 m_allocator = nullptr; 5328 m_dispatcher = nullptr; 5329 return VULKAN_HPP_NAMESPACE::exchange( m_bufferView, nullptr ); 5330 } 5331 getDevice() const5332 VULKAN_HPP_NAMESPACE::Device getDevice() const 5333 { 5334 return m_device; 5335 } 5336 getDispatcher() const5337 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 5338 { 5339 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5340 return m_dispatcher; 5341 } 5342 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView & rhs)5343 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView & rhs ) VULKAN_HPP_NOEXCEPT 5344 { 5345 std::swap( m_device, rhs.m_device ); 5346 std::swap( m_bufferView, rhs.m_bufferView ); 5347 std::swap( m_allocator, rhs.m_allocator ); 5348 std::swap( m_dispatcher, rhs.m_dispatcher ); 5349 } 5350 5351 private: 5352 VULKAN_HPP_NAMESPACE::Device m_device = {}; 5353 VULKAN_HPP_NAMESPACE::BufferView m_bufferView = {}; 5354 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 5355 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 5356 }; 5357 5358 class CommandPool 5359 { 5360 public: 5361 using CType = VkCommandPool; 5362 using CppType = VULKAN_HPP_NAMESPACE::CommandPool; 5363 5364 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool; 5365 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5366 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool; 5367 5368 public: 5369 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)5370 CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5371 VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo, 5372 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5373 { 5374 *this = device.createCommandPool( createInfo, allocator ); 5375 } 5376 # endif 5377 CommandPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCommandPool commandPool,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)5378 CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 5379 VkCommandPool commandPool, 5380 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 5381 : m_device( device ) 5382 , m_commandPool( commandPool ) 5383 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 5384 , m_dispatcher( device.getDispatcher() ) 5385 { 5386 } 5387 CommandPool(std::nullptr_t)5388 CommandPool( std::nullptr_t ) {} 5389 ~CommandPool()5390 ~CommandPool() 5391 { 5392 clear(); 5393 } 5394 5395 CommandPool() = delete; 5396 CommandPool( CommandPool const & ) = delete; 5397 CommandPool(CommandPool && rhs)5398 CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT 5399 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 5400 , m_commandPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) 5401 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 5402 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5403 { 5404 } 5405 5406 CommandPool & operator=( CommandPool const & ) = delete; 5407 operator =(CommandPool && rhs)5408 CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT 5409 { 5410 if ( this != &rhs ) 5411 { 5412 std::swap( m_device, rhs.m_device ); 5413 std::swap( m_commandPool, rhs.m_commandPool ); 5414 std::swap( m_allocator, rhs.m_allocator ); 5415 std::swap( m_dispatcher, rhs.m_dispatcher ); 5416 } 5417 return *this; 5418 } 5419 operator *() const5420 VULKAN_HPP_NAMESPACE::CommandPool const & operator*() const VULKAN_HPP_NOEXCEPT 5421 { 5422 return m_commandPool; 5423 } 5424 operator VULKAN_HPP_NAMESPACE::CommandPool() const5425 operator VULKAN_HPP_NAMESPACE::CommandPool() const VULKAN_HPP_NOEXCEPT 5426 { 5427 return m_commandPool; 5428 } 5429 clear()5430 void clear() VULKAN_HPP_NOEXCEPT 5431 { 5432 if ( m_commandPool ) 5433 { 5434 getDispatcher()->vkDestroyCommandPool( 5435 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 5436 } 5437 m_device = nullptr; 5438 m_commandPool = nullptr; 5439 m_allocator = nullptr; 5440 m_dispatcher = nullptr; 5441 } 5442 release()5443 VULKAN_HPP_NAMESPACE::CommandPool release() 5444 { 5445 m_device = nullptr; 5446 m_allocator = nullptr; 5447 m_dispatcher = nullptr; 5448 return VULKAN_HPP_NAMESPACE::exchange( m_commandPool, nullptr ); 5449 } 5450 getDevice() const5451 VULKAN_HPP_NAMESPACE::Device getDevice() const 5452 { 5453 return m_device; 5454 } 5455 getDispatcher() const5456 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 5457 { 5458 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5459 return m_dispatcher; 5460 } 5461 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool & rhs)5462 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool & rhs ) VULKAN_HPP_NOEXCEPT 5463 { 5464 std::swap( m_device, rhs.m_device ); 5465 std::swap( m_commandPool, rhs.m_commandPool ); 5466 std::swap( m_allocator, rhs.m_allocator ); 5467 std::swap( m_dispatcher, rhs.m_dispatcher ); 5468 } 5469 5470 //=== VK_VERSION_1_0 === 5471 5472 void reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 5473 5474 //=== VK_VERSION_1_1 === 5475 5476 void trim( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5477 5478 //=== VK_KHR_maintenance1 === 5479 5480 void trimKHR( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5481 5482 private: 5483 VULKAN_HPP_NAMESPACE::Device m_device = {}; 5484 VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; 5485 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 5486 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 5487 }; 5488 5489 class CommandBuffer 5490 { 5491 public: 5492 using CType = VkCommandBuffer; 5493 using CppType = VULKAN_HPP_NAMESPACE::CommandBuffer; 5494 5495 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer; 5496 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 5497 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer; 5498 5499 public: CommandBuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCommandBuffer commandBuffer,VkCommandPool commandPool)5500 CommandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkCommandBuffer commandBuffer, VkCommandPool commandPool ) 5501 : m_device( device ), m_commandPool( commandPool ), m_commandBuffer( commandBuffer ), m_dispatcher( device.getDispatcher() ) 5502 { 5503 } 5504 CommandBuffer(std::nullptr_t)5505 CommandBuffer( std::nullptr_t ) {} 5506 ~CommandBuffer()5507 ~CommandBuffer() 5508 { 5509 clear(); 5510 } 5511 5512 CommandBuffer() = delete; 5513 CommandBuffer( CommandBuffer const & ) = delete; 5514 CommandBuffer(CommandBuffer && rhs)5515 CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT 5516 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 5517 , m_commandPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandPool, {} ) ) 5518 , m_commandBuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) ) 5519 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 5520 { 5521 } 5522 5523 CommandBuffer & operator=( CommandBuffer const & ) = delete; 5524 operator =(CommandBuffer && rhs)5525 CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT 5526 { 5527 if ( this != &rhs ) 5528 { 5529 std::swap( m_device, rhs.m_device ); 5530 std::swap( m_commandPool, rhs.m_commandPool ); 5531 std::swap( m_commandBuffer, rhs.m_commandBuffer ); 5532 std::swap( m_dispatcher, rhs.m_dispatcher ); 5533 } 5534 return *this; 5535 } 5536 operator *() const5537 VULKAN_HPP_NAMESPACE::CommandBuffer const & operator*() const VULKAN_HPP_NOEXCEPT 5538 { 5539 return m_commandBuffer; 5540 } 5541 operator VULKAN_HPP_NAMESPACE::CommandBuffer() const5542 operator VULKAN_HPP_NAMESPACE::CommandBuffer() const VULKAN_HPP_NOEXCEPT 5543 { 5544 return m_commandBuffer; 5545 } 5546 clear()5547 void clear() VULKAN_HPP_NOEXCEPT 5548 { 5549 if ( m_commandBuffer ) 5550 { 5551 getDispatcher()->vkFreeCommandBuffers( 5552 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), 1, reinterpret_cast<VkCommandBuffer const *>( &m_commandBuffer ) ); 5553 } 5554 m_device = nullptr; 5555 m_commandPool = nullptr; 5556 m_commandBuffer = nullptr; 5557 m_dispatcher = nullptr; 5558 } 5559 release()5560 VULKAN_HPP_NAMESPACE::CommandBuffer release() 5561 { 5562 m_device = nullptr; 5563 m_commandPool = nullptr; 5564 m_dispatcher = nullptr; 5565 return VULKAN_HPP_NAMESPACE::exchange( m_commandBuffer, nullptr ); 5566 } 5567 getDevice() const5568 VULKAN_HPP_NAMESPACE::Device getDevice() const 5569 { 5570 return m_device; 5571 } 5572 getDispatcher() const5573 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 5574 { 5575 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 5576 return m_dispatcher; 5577 } 5578 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer & rhs)5579 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer & rhs ) VULKAN_HPP_NOEXCEPT 5580 { 5581 std::swap( m_device, rhs.m_device ); 5582 std::swap( m_commandPool, rhs.m_commandPool ); 5583 std::swap( m_commandBuffer, rhs.m_commandBuffer ); 5584 std::swap( m_dispatcher, rhs.m_dispatcher ); 5585 } 5586 5587 //=== VK_VERSION_1_0 === 5588 5589 void begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const; 5590 5591 void end() const; 5592 5593 void reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 5594 5595 void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT; 5596 5597 void setViewport( uint32_t firstViewport, 5598 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT; 5599 5600 void setScissor( uint32_t firstScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT; 5601 5602 void setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT; 5603 5604 void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT; 5605 5606 void setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT; 5607 5608 void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT; 5609 5610 void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT; 5611 5612 void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT; 5613 5614 void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT; 5615 5616 void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 5617 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 5618 uint32_t firstSet, 5619 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, 5620 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT; 5621 5622 void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, 5623 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5624 VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT; 5625 5626 void bindVertexBuffers( uint32_t firstBinding, 5627 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 5628 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const; 5629 5630 void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; 5631 5632 void 5633 drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; 5634 5635 void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 5636 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5637 uint32_t drawCount, 5638 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5639 5640 void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 5641 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5642 uint32_t drawCount, 5643 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5644 5645 void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; 5646 5647 void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT; 5648 5649 void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, 5650 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 5651 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT; 5652 5653 void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, 5654 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 5655 VULKAN_HPP_NAMESPACE::Image dstImage, 5656 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 5657 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT; 5658 5659 void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, 5660 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 5661 VULKAN_HPP_NAMESPACE::Image dstImage, 5662 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 5663 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions, 5664 VULKAN_HPP_NAMESPACE::Filter filter ) const VULKAN_HPP_NOEXCEPT; 5665 5666 void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, 5667 VULKAN_HPP_NAMESPACE::Image dstImage, 5668 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 5669 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT; 5670 5671 void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, 5672 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 5673 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 5674 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT; 5675 5676 template <typename DataType> 5677 void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 5678 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 5679 VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data ) const VULKAN_HPP_NOEXCEPT; 5680 5681 void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 5682 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 5683 VULKAN_HPP_NAMESPACE::DeviceSize size, 5684 uint32_t data ) const VULKAN_HPP_NOEXCEPT; 5685 5686 void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, 5687 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, 5688 const VULKAN_HPP_NAMESPACE::ClearColorValue & color, 5689 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT; 5690 5691 void 5692 clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, 5693 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, 5694 const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil, 5695 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT; 5696 5697 void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments, 5698 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects ) const VULKAN_HPP_NOEXCEPT; 5699 5700 void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, 5701 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 5702 VULKAN_HPP_NAMESPACE::Image dstImage, 5703 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 5704 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT; 5705 5706 void setEvent( VULKAN_HPP_NAMESPACE::Event event, 5707 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5708 5709 void resetEvent( VULKAN_HPP_NAMESPACE::Event event, 5710 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5711 5712 void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 5713 VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, 5714 VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, 5715 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, 5716 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, 5717 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT; 5718 5719 void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, 5720 VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, 5721 VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, 5722 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, 5723 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, 5724 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const 5725 VULKAN_HPP_NOEXCEPT; 5726 5727 void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 5728 uint32_t query, 5729 VULKAN_HPP_NAMESPACE::QueryControlFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5730 5731 void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; 5732 5733 void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; 5734 5735 void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, 5736 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 5737 uint32_t query ) const VULKAN_HPP_NOEXCEPT; 5738 5739 void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 5740 uint32_t firstQuery, 5741 uint32_t queryCount, 5742 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 5743 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 5744 VULKAN_HPP_NAMESPACE::DeviceSize stride, 5745 VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5746 5747 template <typename ValuesType> 5748 void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, 5749 VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, 5750 uint32_t offset, 5751 VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values ) const VULKAN_HPP_NOEXCEPT; 5752 5753 void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 5754 VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT; 5755 5756 void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT; 5757 5758 void endRenderPass() const VULKAN_HPP_NOEXCEPT; 5759 5760 void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const VULKAN_HPP_NOEXCEPT; 5761 5762 //=== VK_VERSION_1_1 === 5763 5764 void setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT; 5765 5766 void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const 5767 VULKAN_HPP_NOEXCEPT; 5768 5769 //=== VK_VERSION_1_2 === 5770 5771 void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, 5772 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5773 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 5774 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 5775 uint32_t maxDrawCount, 5776 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5777 5778 void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, 5779 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5780 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 5781 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 5782 uint32_t maxDrawCount, 5783 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5784 5785 void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 5786 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT; 5787 5788 void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, 5789 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; 5790 5791 void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; 5792 5793 //=== VK_VERSION_1_3 === 5794 5795 void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; 5796 5797 void resetEvent2( VULKAN_HPP_NAMESPACE::Event event, 5798 VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5799 5800 void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 5801 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos ) const; 5802 5803 void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; 5804 5805 void 5806 writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; 5807 5808 void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT; 5809 5810 void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT; 5811 5812 void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT; 5813 5814 void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT; 5815 5816 void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT; 5817 5818 void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT; 5819 5820 void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT; 5821 5822 void endRendering() const VULKAN_HPP_NOEXCEPT; 5823 5824 void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 5825 5826 void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT; 5827 5828 void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT; 5829 5830 void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT; 5831 5832 void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT; 5833 5834 void bindVertexBuffers2( 5835 uint32_t firstBinding, 5836 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 5837 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 5838 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, 5839 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 5840 5841 void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT; 5842 5843 void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT; 5844 5845 void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT; 5846 5847 void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT; 5848 5849 void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT; 5850 5851 void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 5852 VULKAN_HPP_NAMESPACE::StencilOp failOp, 5853 VULKAN_HPP_NAMESPACE::StencilOp passOp, 5854 VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, 5855 VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT; 5856 5857 void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT; 5858 5859 void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT; 5860 5861 void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT; 5862 5863 //=== VK_VERSION_1_4 === 5864 5865 void setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; 5866 5867 void bindIndexBuffer2( VULKAN_HPP_NAMESPACE::Buffer buffer, 5868 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5869 VULKAN_HPP_NAMESPACE::DeviceSize size, 5870 VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT; 5871 5872 void pushDescriptorSet( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 5873 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 5874 uint32_t set, 5875 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const 5876 VULKAN_HPP_NOEXCEPT; 5877 5878 template <typename DataType> 5879 void pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 5880 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 5881 uint32_t set, 5882 DataType const & data ) const VULKAN_HPP_NOEXCEPT; 5883 5884 void setRenderingAttachmentLocations( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT; 5885 5886 void setRenderingInputAttachmentIndices( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const 5887 VULKAN_HPP_NOEXCEPT; 5888 5889 void bindDescriptorSets2( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT; 5890 5891 void pushConstants2( const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT; 5892 5893 void pushDescriptorSet2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT; 5894 5895 void pushDescriptorSetWithTemplate2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const 5896 VULKAN_HPP_NOEXCEPT; 5897 5898 //=== VK_EXT_debug_marker === 5899 5900 void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT; 5901 5902 void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT; 5903 5904 void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT; 5905 5906 //=== VK_KHR_video_queue === 5907 5908 void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT; 5909 5910 void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT; 5911 5912 void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT; 5913 5914 //=== VK_KHR_video_decode_queue === 5915 5916 void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT; 5917 5918 //=== VK_EXT_transform_feedback === 5919 5920 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, 5921 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 5922 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 5923 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes 5924 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 5925 5926 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, 5927 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, 5928 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets 5929 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 5930 5931 void endTransformFeedbackEXT( uint32_t firstCounterBuffer, 5932 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, 5933 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets 5934 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 5935 5936 void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 5937 uint32_t query, 5938 VULKAN_HPP_NAMESPACE::QueryControlFlags flags, 5939 uint32_t index ) const VULKAN_HPP_NOEXCEPT; 5940 5941 void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT; 5942 5943 void drawIndirectByteCountEXT( uint32_t instanceCount, 5944 uint32_t firstInstance, 5945 VULKAN_HPP_NAMESPACE::Buffer counterBuffer, 5946 VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, 5947 uint32_t counterOffset, 5948 uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT; 5949 5950 //=== VK_NVX_binary_import === 5951 5952 void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT; 5953 5954 //=== VK_AMD_draw_indirect_count === 5955 5956 void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, 5957 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5958 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 5959 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 5960 uint32_t maxDrawCount, 5961 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5962 5963 void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, 5964 VULKAN_HPP_NAMESPACE::DeviceSize offset, 5965 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 5966 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 5967 uint32_t maxDrawCount, 5968 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 5969 5970 //=== VK_KHR_dynamic_rendering === 5971 5972 void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT; 5973 5974 void endRenderingKHR() const VULKAN_HPP_NOEXCEPT; 5975 5976 //=== VK_KHR_device_group === 5977 5978 void setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT; 5979 5980 void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) 5981 const VULKAN_HPP_NOEXCEPT; 5982 5983 //=== VK_KHR_push_descriptor === 5984 5985 void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 5986 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 5987 uint32_t set, 5988 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const 5989 VULKAN_HPP_NOEXCEPT; 5990 5991 template <typename DataType> 5992 void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 5993 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 5994 uint32_t set, 5995 DataType const & data ) const VULKAN_HPP_NOEXCEPT; 5996 5997 //=== VK_EXT_conditional_rendering === 5998 5999 void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT; 6000 6001 void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT; 6002 6003 //=== VK_NV_clip_space_w_scaling === 6004 6005 void setViewportWScalingNV( uint32_t firstViewport, 6006 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) const 6007 VULKAN_HPP_NOEXCEPT; 6008 6009 //=== VK_EXT_discard_rectangles === 6010 6011 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, 6012 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT; 6013 6014 void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT; 6015 6016 void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT; 6017 6018 //=== VK_KHR_create_renderpass2 === 6019 6020 void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 6021 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT; 6022 6023 void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, 6024 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; 6025 6026 void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; 6027 6028 //=== VK_EXT_debug_utils === 6029 6030 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; 6031 6032 void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; 6033 6034 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; 6035 6036 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 6037 //=== VK_AMDX_shader_enqueue === 6038 6039 void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch ) const VULKAN_HPP_NOEXCEPT; 6040 6041 void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, 6042 const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT; 6043 6044 void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, 6045 const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT; 6046 6047 void dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, 6048 VULKAN_HPP_NAMESPACE::DeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT; 6049 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 6050 6051 //=== VK_EXT_sample_locations === 6052 6053 void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT; 6054 6055 //=== VK_KHR_acceleration_structure === 6056 6057 void buildAccelerationStructuresKHR( 6058 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 6059 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) const; 6060 6061 void buildAccelerationStructuresIndirectKHR( 6062 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 6063 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses, 6064 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides, 6065 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const; 6066 6067 void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; 6068 6069 void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; 6070 6071 void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; 6072 6073 void writeAccelerationStructuresPropertiesKHR( 6074 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 6075 VULKAN_HPP_NAMESPACE::QueryType queryType, 6076 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 6077 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; 6078 6079 //=== VK_KHR_ray_tracing_pipeline === 6080 6081 void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, 6082 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, 6083 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, 6084 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, 6085 uint32_t width, 6086 uint32_t height, 6087 uint32_t depth ) const VULKAN_HPP_NOEXCEPT; 6088 6089 void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, 6090 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, 6091 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, 6092 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, 6093 VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT; 6094 6095 void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT; 6096 6097 //=== VK_NV_shading_rate_image === 6098 6099 void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT; 6100 6101 void setViewportShadingRatePaletteNV( 6102 uint32_t firstViewport, 6103 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT; 6104 6105 void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, 6106 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders ) const 6107 VULKAN_HPP_NOEXCEPT; 6108 6109 //=== VK_NV_ray_tracing === 6110 6111 void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info, 6112 VULKAN_HPP_NAMESPACE::Buffer instanceData, 6113 VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, 6114 VULKAN_HPP_NAMESPACE::Bool32 update, 6115 VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, 6116 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, 6117 VULKAN_HPP_NAMESPACE::Buffer scratch, 6118 VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT; 6119 6120 void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, 6121 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, 6122 VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT; 6123 6124 void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, 6125 VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, 6126 VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, 6127 VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, 6128 VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, 6129 VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, 6130 VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, 6131 VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, 6132 VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, 6133 VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, 6134 VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, 6135 uint32_t width, 6136 uint32_t height, 6137 uint32_t depth ) const VULKAN_HPP_NOEXCEPT; 6138 6139 void writeAccelerationStructuresPropertiesNV( 6140 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures, 6141 VULKAN_HPP_NAMESPACE::QueryType queryType, 6142 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 6143 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; 6144 6145 //=== VK_KHR_draw_indirect_count === 6146 6147 void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 6148 VULKAN_HPP_NAMESPACE::DeviceSize offset, 6149 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 6150 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 6151 uint32_t maxDrawCount, 6152 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 6153 6154 void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 6155 VULKAN_HPP_NAMESPACE::DeviceSize offset, 6156 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 6157 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 6158 uint32_t maxDrawCount, 6159 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 6160 6161 //=== VK_AMD_buffer_marker === 6162 6163 void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, 6164 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 6165 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 6166 uint32_t marker ) const VULKAN_HPP_NOEXCEPT; 6167 6168 //=== VK_NV_mesh_shader === 6169 6170 void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT; 6171 6172 void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, 6173 VULKAN_HPP_NAMESPACE::DeviceSize offset, 6174 uint32_t drawCount, 6175 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 6176 6177 void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, 6178 VULKAN_HPP_NAMESPACE::DeviceSize offset, 6179 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 6180 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 6181 uint32_t maxDrawCount, 6182 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 6183 6184 //=== VK_NV_scissor_exclusive === 6185 6186 void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, 6187 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables ) const 6188 VULKAN_HPP_NOEXCEPT; 6189 6190 void setExclusiveScissorNV( uint32_t firstExclusiveScissor, 6191 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT; 6192 6193 //=== VK_NV_device_diagnostic_checkpoints === 6194 6195 template <typename CheckpointMarkerType> 6196 void setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT; 6197 6198 //=== VK_INTEL_performance_query === 6199 6200 void setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo ) const; 6201 6202 void setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo ) const; 6203 6204 void setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo ) const; 6205 6206 //=== VK_KHR_fragment_shading_rate === 6207 6208 void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize, 6209 const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; 6210 6211 //=== VK_KHR_dynamic_rendering_local_read === 6212 6213 void setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT; 6214 6215 void setRenderingInputAttachmentIndicesKHR( const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const 6216 VULKAN_HPP_NOEXCEPT; 6217 6218 //=== VK_EXT_line_rasterization === 6219 6220 void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; 6221 6222 //=== VK_EXT_extended_dynamic_state === 6223 6224 void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 6225 6226 void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT; 6227 6228 void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT; 6229 6230 void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT; 6231 6232 void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT; 6233 6234 void bindVertexBuffers2EXT( 6235 uint32_t firstBinding, 6236 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 6237 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 6238 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, 6239 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const; 6240 6241 void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT; 6242 6243 void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT; 6244 6245 void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT; 6246 6247 void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT; 6248 6249 void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT; 6250 6251 void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 6252 VULKAN_HPP_NAMESPACE::StencilOp failOp, 6253 VULKAN_HPP_NAMESPACE::StencilOp passOp, 6254 VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, 6255 VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT; 6256 6257 //=== VK_NV_device_generated_commands === 6258 6259 void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; 6260 6261 void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, 6262 const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; 6263 6264 void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 6265 VULKAN_HPP_NAMESPACE::Pipeline pipeline, 6266 uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT; 6267 6268 //=== VK_EXT_depth_bias_control === 6269 6270 void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo ) const VULKAN_HPP_NOEXCEPT; 6271 6272 //=== VK_KHR_video_encode_queue === 6273 6274 void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT; 6275 6276 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 6277 //=== VK_NV_cuda_kernel_launch === 6278 6279 void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo ) const VULKAN_HPP_NOEXCEPT; 6280 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 6281 6282 //=== VK_KHR_synchronization2 === 6283 6284 void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; 6285 6286 void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, 6287 VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 6288 6289 void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 6290 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos ) const; 6291 6292 void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; 6293 6294 void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, 6295 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 6296 uint32_t query ) const VULKAN_HPP_NOEXCEPT; 6297 6298 void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, 6299 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 6300 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 6301 uint32_t marker ) const VULKAN_HPP_NOEXCEPT; 6302 6303 //=== VK_EXT_descriptor_buffer === 6304 6305 void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos ) const 6306 VULKAN_HPP_NOEXCEPT; 6307 6308 void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 6309 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 6310 uint32_t firstSet, 6311 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices, 6312 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const; 6313 6314 void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 6315 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 6316 uint32_t set ) const VULKAN_HPP_NOEXCEPT; 6317 6318 //=== VK_NV_fragment_shading_rate_enums === 6319 6320 void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, 6321 const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; 6322 6323 //=== VK_EXT_mesh_shader === 6324 6325 void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; 6326 6327 void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, 6328 VULKAN_HPP_NAMESPACE::DeviceSize offset, 6329 uint32_t drawCount, 6330 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 6331 6332 void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, 6333 VULKAN_HPP_NAMESPACE::DeviceSize offset, 6334 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 6335 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 6336 uint32_t maxDrawCount, 6337 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 6338 6339 //=== VK_KHR_copy_commands2 === 6340 6341 void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT; 6342 6343 void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT; 6344 6345 void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT; 6346 6347 void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT; 6348 6349 void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT; 6350 6351 void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT; 6352 6353 //=== VK_EXT_vertex_input_dynamic_state === 6354 6355 void setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions, 6356 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & 6357 vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT; 6358 6359 //=== VK_HUAWEI_subpass_shading === 6360 6361 void subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT; 6362 6363 //=== VK_HUAWEI_invocation_mask === 6364 6365 void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT; 6366 6367 //=== VK_EXT_extended_dynamic_state2 === 6368 6369 void setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT; 6370 6371 void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT; 6372 6373 void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT; 6374 6375 void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT; 6376 6377 void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT; 6378 6379 //=== VK_EXT_color_write_enable === 6380 6381 void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT; 6382 6383 //=== VK_KHR_ray_tracing_maintenance1 === 6384 6385 void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT; 6386 6387 //=== VK_EXT_multi_draw === 6388 6389 void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo, 6390 uint32_t instanceCount, 6391 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; 6392 6393 void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo, 6394 uint32_t instanceCount, 6395 uint32_t firstInstance, 6396 Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 6397 6398 //=== VK_EXT_opacity_micromap === 6399 6400 void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos ) const VULKAN_HPP_NOEXCEPT; 6401 6402 void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; 6403 6404 void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; 6405 6406 void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; 6407 6408 void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, 6409 VULKAN_HPP_NAMESPACE::QueryType queryType, 6410 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 6411 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; 6412 6413 //=== VK_HUAWEI_cluster_culling_shader === 6414 6415 void drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; 6416 6417 void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT; 6418 6419 //=== VK_NV_copy_memory_indirect === 6420 6421 void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 6422 6423 void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, 6424 uint32_t stride, 6425 VULKAN_HPP_NAMESPACE::Image dstImage, 6426 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 6427 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources ) const 6428 VULKAN_HPP_NOEXCEPT; 6429 6430 //=== VK_NV_memory_decompression === 6431 6432 void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions ) const 6433 VULKAN_HPP_NOEXCEPT; 6434 6435 void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress, 6436 VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress, 6437 uint32_t stride ) const VULKAN_HPP_NOEXCEPT; 6438 6439 //=== VK_NV_device_generated_commands_compute === 6440 6441 void updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 6442 VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT; 6443 6444 //=== VK_EXT_extended_dynamic_state3 === 6445 6446 void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT; 6447 6448 void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT; 6449 6450 void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT; 6451 6452 void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, 6453 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask ) const; 6454 6455 void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT; 6456 6457 void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT; 6458 6459 void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT; 6460 6461 void setColorBlendEnableEXT( uint32_t firstAttachment, 6462 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT; 6463 6464 void setColorBlendEquationEXT( uint32_t firstAttachment, 6465 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations ) const 6466 VULKAN_HPP_NOEXCEPT; 6467 6468 void setColorWriteMaskEXT( uint32_t firstAttachment, 6469 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks ) const 6470 VULKAN_HPP_NOEXCEPT; 6471 6472 void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT; 6473 6474 void setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT; 6475 6476 void 6477 setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT; 6478 6479 void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT; 6480 6481 void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT; 6482 6483 void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT; 6484 6485 void setColorBlendAdvancedEXT( uint32_t firstAttachment, 6486 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced ) const 6487 VULKAN_HPP_NOEXCEPT; 6488 6489 void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT; 6490 6491 void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT; 6492 6493 void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT; 6494 6495 void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT; 6496 6497 void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT; 6498 6499 void setViewportSwizzleNV( uint32_t firstViewport, 6500 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles ) const 6501 VULKAN_HPP_NOEXCEPT; 6502 6503 void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT; 6504 6505 void setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT; 6506 6507 void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT; 6508 6509 void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT; 6510 6511 void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT; 6512 6513 void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT; 6514 6515 void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT; 6516 6517 void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT; 6518 6519 //=== VK_NV_optical_flow === 6520 6521 void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, 6522 const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT; 6523 6524 //=== VK_KHR_maintenance5 === 6525 6526 void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 6527 VULKAN_HPP_NAMESPACE::DeviceSize offset, 6528 VULKAN_HPP_NAMESPACE::DeviceSize size, 6529 VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT; 6530 6531 //=== VK_EXT_shader_object === 6532 6533 void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages, 6534 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & shaders ) const; 6535 6536 //=== VK_EXT_attachment_feedback_loop_dynamic_state === 6537 6538 void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const 6539 VULKAN_HPP_NOEXCEPT; 6540 6541 //=== VK_KHR_line_rasterization === 6542 6543 void setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; 6544 6545 //=== VK_KHR_maintenance6 === 6546 6547 void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT; 6548 6549 void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT; 6550 6551 void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT; 6552 6553 void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const 6554 VULKAN_HPP_NOEXCEPT; 6555 6556 void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo ) const 6557 VULKAN_HPP_NOEXCEPT; 6558 6559 void bindDescriptorBufferEmbeddedSamplers2EXT( 6560 const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT; 6561 6562 private: 6563 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6564 VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; 6565 VULKAN_HPP_NAMESPACE::CommandBuffer m_commandBuffer = {}; 6566 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6567 }; 6568 6569 class CommandBuffers : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> 6570 { 6571 public: 6572 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) CommandBuffers(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo)6573 CommandBuffers( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6574 VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) 6575 { 6576 *this = device.allocateCommandBuffers( allocateInfo ); 6577 } 6578 # endif 6579 CommandBuffers(std::nullptr_t)6580 CommandBuffers( std::nullptr_t ) {} 6581 6582 CommandBuffers() = delete; 6583 CommandBuffers( CommandBuffers const & ) = delete; 6584 CommandBuffers( CommandBuffers && rhs ) = default; 6585 CommandBuffers & operator=( CommandBuffers const & ) = delete; 6586 CommandBuffers & operator=( CommandBuffers && rhs ) = default; 6587 6588 private: CommandBuffers(std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> && rhs)6589 CommandBuffers( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> && rhs ) 6590 { 6591 std::swap( *this, rhs ); 6592 } 6593 }; 6594 6595 class CuFunctionNVX 6596 { 6597 public: 6598 using CType = VkCuFunctionNVX; 6599 using CppType = VULKAN_HPP_NAMESPACE::CuFunctionNVX; 6600 6601 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX; 6602 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6603 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX; 6604 6605 public: 6606 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)6607 CuFunctionNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6608 VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo, 6609 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6610 { 6611 *this = device.createCuFunctionNVX( createInfo, allocator ); 6612 } 6613 # endif 6614 CuFunctionNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCuFunctionNVX function,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6615 CuFunctionNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6616 VkCuFunctionNVX function, 6617 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6618 : m_device( device ) 6619 , m_function( function ) 6620 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6621 , m_dispatcher( device.getDispatcher() ) 6622 { 6623 } 6624 CuFunctionNVX(std::nullptr_t)6625 CuFunctionNVX( std::nullptr_t ) {} 6626 ~CuFunctionNVX()6627 ~CuFunctionNVX() 6628 { 6629 clear(); 6630 } 6631 6632 CuFunctionNVX() = delete; 6633 CuFunctionNVX( CuFunctionNVX const & ) = delete; 6634 CuFunctionNVX(CuFunctionNVX && rhs)6635 CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT 6636 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 6637 , m_function( VULKAN_HPP_NAMESPACE::exchange( rhs.m_function, {} ) ) 6638 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6639 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6640 { 6641 } 6642 6643 CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete; 6644 operator =(CuFunctionNVX && rhs)6645 CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT 6646 { 6647 if ( this != &rhs ) 6648 { 6649 std::swap( m_device, rhs.m_device ); 6650 std::swap( m_function, rhs.m_function ); 6651 std::swap( m_allocator, rhs.m_allocator ); 6652 std::swap( m_dispatcher, rhs.m_dispatcher ); 6653 } 6654 return *this; 6655 } 6656 operator *() const6657 VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT 6658 { 6659 return m_function; 6660 } 6661 operator VULKAN_HPP_NAMESPACE::CuFunctionNVX() const6662 operator VULKAN_HPP_NAMESPACE::CuFunctionNVX() const VULKAN_HPP_NOEXCEPT 6663 { 6664 return m_function; 6665 } 6666 clear()6667 void clear() VULKAN_HPP_NOEXCEPT 6668 { 6669 if ( m_function ) 6670 { 6671 getDispatcher()->vkDestroyCuFunctionNVX( 6672 static_cast<VkDevice>( m_device ), static_cast<VkCuFunctionNVX>( m_function ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6673 } 6674 m_device = nullptr; 6675 m_function = nullptr; 6676 m_allocator = nullptr; 6677 m_dispatcher = nullptr; 6678 } 6679 release()6680 VULKAN_HPP_NAMESPACE::CuFunctionNVX release() 6681 { 6682 m_device = nullptr; 6683 m_allocator = nullptr; 6684 m_dispatcher = nullptr; 6685 return VULKAN_HPP_NAMESPACE::exchange( m_function, nullptr ); 6686 } 6687 getDevice() const6688 VULKAN_HPP_NAMESPACE::Device getDevice() const 6689 { 6690 return m_device; 6691 } 6692 getDispatcher() const6693 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 6694 { 6695 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6696 return m_dispatcher; 6697 } 6698 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX & rhs)6699 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX & rhs ) VULKAN_HPP_NOEXCEPT 6700 { 6701 std::swap( m_device, rhs.m_device ); 6702 std::swap( m_function, rhs.m_function ); 6703 std::swap( m_allocator, rhs.m_allocator ); 6704 std::swap( m_dispatcher, rhs.m_dispatcher ); 6705 } 6706 6707 private: 6708 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6709 VULKAN_HPP_NAMESPACE::CuFunctionNVX m_function = {}; 6710 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 6711 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6712 }; 6713 6714 class CuModuleNVX 6715 { 6716 public: 6717 using CType = VkCuModuleNVX; 6718 using CppType = VULKAN_HPP_NAMESPACE::CuModuleNVX; 6719 6720 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX; 6721 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6722 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX; 6723 6724 public: 6725 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)6726 CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6727 VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo, 6728 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6729 { 6730 *this = device.createCuModuleNVX( createInfo, allocator ); 6731 } 6732 # endif 6733 CuModuleNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCuModuleNVX module,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6734 CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6735 VkCuModuleNVX module, 6736 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6737 : m_device( device ) 6738 , m_module( module ) 6739 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6740 , m_dispatcher( device.getDispatcher() ) 6741 { 6742 } 6743 CuModuleNVX(std::nullptr_t)6744 CuModuleNVX( std::nullptr_t ) {} 6745 ~CuModuleNVX()6746 ~CuModuleNVX() 6747 { 6748 clear(); 6749 } 6750 6751 CuModuleNVX() = delete; 6752 CuModuleNVX( CuModuleNVX const & ) = delete; 6753 CuModuleNVX(CuModuleNVX && rhs)6754 CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT 6755 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 6756 , m_module( VULKAN_HPP_NAMESPACE::exchange( rhs.m_module, {} ) ) 6757 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6758 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6759 { 6760 } 6761 6762 CuModuleNVX & operator=( CuModuleNVX const & ) = delete; 6763 operator =(CuModuleNVX && rhs)6764 CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT 6765 { 6766 if ( this != &rhs ) 6767 { 6768 std::swap( m_device, rhs.m_device ); 6769 std::swap( m_module, rhs.m_module ); 6770 std::swap( m_allocator, rhs.m_allocator ); 6771 std::swap( m_dispatcher, rhs.m_dispatcher ); 6772 } 6773 return *this; 6774 } 6775 operator *() const6776 VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const VULKAN_HPP_NOEXCEPT 6777 { 6778 return m_module; 6779 } 6780 operator VULKAN_HPP_NAMESPACE::CuModuleNVX() const6781 operator VULKAN_HPP_NAMESPACE::CuModuleNVX() const VULKAN_HPP_NOEXCEPT 6782 { 6783 return m_module; 6784 } 6785 clear()6786 void clear() VULKAN_HPP_NOEXCEPT 6787 { 6788 if ( m_module ) 6789 { 6790 getDispatcher()->vkDestroyCuModuleNVX( 6791 static_cast<VkDevice>( m_device ), static_cast<VkCuModuleNVX>( m_module ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6792 } 6793 m_device = nullptr; 6794 m_module = nullptr; 6795 m_allocator = nullptr; 6796 m_dispatcher = nullptr; 6797 } 6798 release()6799 VULKAN_HPP_NAMESPACE::CuModuleNVX release() 6800 { 6801 m_device = nullptr; 6802 m_allocator = nullptr; 6803 m_dispatcher = nullptr; 6804 return VULKAN_HPP_NAMESPACE::exchange( m_module, nullptr ); 6805 } 6806 getDevice() const6807 VULKAN_HPP_NAMESPACE::Device getDevice() const 6808 { 6809 return m_device; 6810 } 6811 getDispatcher() const6812 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 6813 { 6814 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6815 return m_dispatcher; 6816 } 6817 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX & rhs)6818 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX & rhs ) VULKAN_HPP_NOEXCEPT 6819 { 6820 std::swap( m_device, rhs.m_device ); 6821 std::swap( m_module, rhs.m_module ); 6822 std::swap( m_allocator, rhs.m_allocator ); 6823 std::swap( m_dispatcher, rhs.m_dispatcher ); 6824 } 6825 6826 private: 6827 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6828 VULKAN_HPP_NAMESPACE::CuModuleNVX m_module = {}; 6829 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 6830 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6831 }; 6832 6833 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 6834 class CudaFunctionNV 6835 { 6836 public: 6837 using CType = VkCudaFunctionNV; 6838 using CppType = VULKAN_HPP_NAMESPACE::CudaFunctionNV; 6839 6840 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV; 6841 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6842 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV; 6843 6844 public: 6845 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) CudaFunctionNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6846 CudaFunctionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6847 VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & createInfo, 6848 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6849 { 6850 *this = device.createCudaFunctionNV( createInfo, allocator ); 6851 } 6852 # endif 6853 CudaFunctionNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCudaFunctionNV function,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6854 CudaFunctionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6855 VkCudaFunctionNV function, 6856 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6857 : m_device( device ) 6858 , m_function( function ) 6859 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6860 , m_dispatcher( device.getDispatcher() ) 6861 { 6862 } 6863 CudaFunctionNV(std::nullptr_t)6864 CudaFunctionNV( std::nullptr_t ) {} 6865 ~CudaFunctionNV()6866 ~CudaFunctionNV() 6867 { 6868 clear(); 6869 } 6870 6871 CudaFunctionNV() = delete; 6872 CudaFunctionNV( CudaFunctionNV const & ) = delete; 6873 CudaFunctionNV(CudaFunctionNV && rhs)6874 CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT 6875 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 6876 , m_function( VULKAN_HPP_NAMESPACE::exchange( rhs.m_function, {} ) ) 6877 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6878 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 6879 { 6880 } 6881 6882 CudaFunctionNV & operator=( CudaFunctionNV const & ) = delete; 6883 operator =(CudaFunctionNV && rhs)6884 CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT 6885 { 6886 if ( this != &rhs ) 6887 { 6888 std::swap( m_device, rhs.m_device ); 6889 std::swap( m_function, rhs.m_function ); 6890 std::swap( m_allocator, rhs.m_allocator ); 6891 std::swap( m_dispatcher, rhs.m_dispatcher ); 6892 } 6893 return *this; 6894 } 6895 operator *() const6896 VULKAN_HPP_NAMESPACE::CudaFunctionNV const & operator*() const VULKAN_HPP_NOEXCEPT 6897 { 6898 return m_function; 6899 } 6900 operator VULKAN_HPP_NAMESPACE::CudaFunctionNV() const6901 operator VULKAN_HPP_NAMESPACE::CudaFunctionNV() const VULKAN_HPP_NOEXCEPT 6902 { 6903 return m_function; 6904 } 6905 clear()6906 void clear() VULKAN_HPP_NOEXCEPT 6907 { 6908 if ( m_function ) 6909 { 6910 getDispatcher()->vkDestroyCudaFunctionNV( 6911 static_cast<VkDevice>( m_device ), static_cast<VkCudaFunctionNV>( m_function ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 6912 } 6913 m_device = nullptr; 6914 m_function = nullptr; 6915 m_allocator = nullptr; 6916 m_dispatcher = nullptr; 6917 } 6918 release()6919 VULKAN_HPP_NAMESPACE::CudaFunctionNV release() 6920 { 6921 m_device = nullptr; 6922 m_allocator = nullptr; 6923 m_dispatcher = nullptr; 6924 return VULKAN_HPP_NAMESPACE::exchange( m_function, nullptr ); 6925 } 6926 getDevice() const6927 VULKAN_HPP_NAMESPACE::Device getDevice() const 6928 { 6929 return m_device; 6930 } 6931 getDispatcher() const6932 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 6933 { 6934 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 6935 return m_dispatcher; 6936 } 6937 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV & rhs)6938 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV & rhs ) VULKAN_HPP_NOEXCEPT 6939 { 6940 std::swap( m_device, rhs.m_device ); 6941 std::swap( m_function, rhs.m_function ); 6942 std::swap( m_allocator, rhs.m_allocator ); 6943 std::swap( m_dispatcher, rhs.m_dispatcher ); 6944 } 6945 6946 private: 6947 VULKAN_HPP_NAMESPACE::Device m_device = {}; 6948 VULKAN_HPP_NAMESPACE::CudaFunctionNV m_function = {}; 6949 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 6950 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 6951 }; 6952 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 6953 6954 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 6955 class CudaModuleNV 6956 { 6957 public: 6958 using CType = VkCudaModuleNV; 6959 using CppType = VULKAN_HPP_NAMESPACE::CudaModuleNV; 6960 6961 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV; 6962 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 6963 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV; 6964 6965 public: 6966 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) CudaModuleNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6967 CudaModuleNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6968 VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & createInfo, 6969 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6970 { 6971 *this = device.createCudaModuleNV( createInfo, allocator ); 6972 } 6973 # endif 6974 CudaModuleNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkCudaModuleNV module,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)6975 CudaModuleNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 6976 VkCudaModuleNV module, 6977 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 6978 : m_device( device ) 6979 , m_module( module ) 6980 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 6981 , m_dispatcher( device.getDispatcher() ) 6982 { 6983 } 6984 CudaModuleNV(std::nullptr_t)6985 CudaModuleNV( std::nullptr_t ) {} 6986 ~CudaModuleNV()6987 ~CudaModuleNV() 6988 { 6989 clear(); 6990 } 6991 6992 CudaModuleNV() = delete; 6993 CudaModuleNV( CudaModuleNV const & ) = delete; 6994 CudaModuleNV(CudaModuleNV && rhs)6995 CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT 6996 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 6997 , m_module( VULKAN_HPP_NAMESPACE::exchange( rhs.m_module, {} ) ) 6998 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 6999 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7000 { 7001 } 7002 7003 CudaModuleNV & operator=( CudaModuleNV const & ) = delete; 7004 operator =(CudaModuleNV && rhs)7005 CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT 7006 { 7007 if ( this != &rhs ) 7008 { 7009 std::swap( m_device, rhs.m_device ); 7010 std::swap( m_module, rhs.m_module ); 7011 std::swap( m_allocator, rhs.m_allocator ); 7012 std::swap( m_dispatcher, rhs.m_dispatcher ); 7013 } 7014 return *this; 7015 } 7016 operator *() const7017 VULKAN_HPP_NAMESPACE::CudaModuleNV const & operator*() const VULKAN_HPP_NOEXCEPT 7018 { 7019 return m_module; 7020 } 7021 operator VULKAN_HPP_NAMESPACE::CudaModuleNV() const7022 operator VULKAN_HPP_NAMESPACE::CudaModuleNV() const VULKAN_HPP_NOEXCEPT 7023 { 7024 return m_module; 7025 } 7026 clear()7027 void clear() VULKAN_HPP_NOEXCEPT 7028 { 7029 if ( m_module ) 7030 { 7031 getDispatcher()->vkDestroyCudaModuleNV( 7032 static_cast<VkDevice>( m_device ), static_cast<VkCudaModuleNV>( m_module ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7033 } 7034 m_device = nullptr; 7035 m_module = nullptr; 7036 m_allocator = nullptr; 7037 m_dispatcher = nullptr; 7038 } 7039 release()7040 VULKAN_HPP_NAMESPACE::CudaModuleNV release() 7041 { 7042 m_device = nullptr; 7043 m_allocator = nullptr; 7044 m_dispatcher = nullptr; 7045 return VULKAN_HPP_NAMESPACE::exchange( m_module, nullptr ); 7046 } 7047 getDevice() const7048 VULKAN_HPP_NAMESPACE::Device getDevice() const 7049 { 7050 return m_device; 7051 } 7052 getDispatcher() const7053 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7054 { 7055 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7056 return m_dispatcher; 7057 } 7058 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV & rhs)7059 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV & rhs ) VULKAN_HPP_NOEXCEPT 7060 { 7061 std::swap( m_device, rhs.m_device ); 7062 std::swap( m_module, rhs.m_module ); 7063 std::swap( m_allocator, rhs.m_allocator ); 7064 std::swap( m_dispatcher, rhs.m_dispatcher ); 7065 } 7066 7067 //=== VK_NV_cuda_kernel_launch === 7068 7069 VULKAN_HPP_NODISCARD std::vector<uint8_t> getCache() const; 7070 7071 private: 7072 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7073 VULKAN_HPP_NAMESPACE::CudaModuleNV m_module = {}; 7074 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 7075 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7076 }; 7077 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7078 7079 class DebugReportCallbackEXT 7080 { 7081 public: 7082 using CType = VkDebugReportCallbackEXT; 7083 using CppType = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT; 7084 7085 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT; 7086 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7087 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT; 7088 7089 public: 7090 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)7091 DebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 7092 VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo, 7093 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7094 { 7095 *this = instance.createDebugReportCallbackEXT( createInfo, allocator ); 7096 } 7097 # endif 7098 DebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VkDebugReportCallbackEXT callback,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7099 DebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 7100 VkDebugReportCallbackEXT callback, 7101 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7102 : m_instance( instance ) 7103 , m_callback( callback ) 7104 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7105 , m_dispatcher( instance.getDispatcher() ) 7106 { 7107 } 7108 DebugReportCallbackEXT(std::nullptr_t)7109 DebugReportCallbackEXT( std::nullptr_t ) {} 7110 ~DebugReportCallbackEXT()7111 ~DebugReportCallbackEXT() 7112 { 7113 clear(); 7114 } 7115 7116 DebugReportCallbackEXT() = delete; 7117 DebugReportCallbackEXT( DebugReportCallbackEXT const & ) = delete; 7118 DebugReportCallbackEXT(DebugReportCallbackEXT && rhs)7119 DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT 7120 : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) 7121 , m_callback( VULKAN_HPP_NAMESPACE::exchange( rhs.m_callback, {} ) ) 7122 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7123 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7124 { 7125 } 7126 7127 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & ) = delete; 7128 operator =(DebugReportCallbackEXT && rhs)7129 DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT 7130 { 7131 if ( this != &rhs ) 7132 { 7133 std::swap( m_instance, rhs.m_instance ); 7134 std::swap( m_callback, rhs.m_callback ); 7135 std::swap( m_allocator, rhs.m_allocator ); 7136 std::swap( m_dispatcher, rhs.m_dispatcher ); 7137 } 7138 return *this; 7139 } 7140 operator *() const7141 VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const VULKAN_HPP_NOEXCEPT 7142 { 7143 return m_callback; 7144 } 7145 operator VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT() const7146 operator VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT 7147 { 7148 return m_callback; 7149 } 7150 clear()7151 void clear() VULKAN_HPP_NOEXCEPT 7152 { 7153 if ( m_callback ) 7154 { 7155 getDispatcher()->vkDestroyDebugReportCallbackEXT( static_cast<VkInstance>( m_instance ), 7156 static_cast<VkDebugReportCallbackEXT>( m_callback ), 7157 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7158 } 7159 m_instance = nullptr; 7160 m_callback = nullptr; 7161 m_allocator = nullptr; 7162 m_dispatcher = nullptr; 7163 } 7164 release()7165 VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT release() 7166 { 7167 m_instance = nullptr; 7168 m_allocator = nullptr; 7169 m_dispatcher = nullptr; 7170 return VULKAN_HPP_NAMESPACE::exchange( m_callback, nullptr ); 7171 } 7172 getInstance() const7173 VULKAN_HPP_NAMESPACE::Instance getInstance() const 7174 { 7175 return m_instance; 7176 } 7177 getDispatcher() const7178 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 7179 { 7180 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7181 return m_dispatcher; 7182 } 7183 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT & rhs)7184 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT & rhs ) VULKAN_HPP_NOEXCEPT 7185 { 7186 std::swap( m_instance, rhs.m_instance ); 7187 std::swap( m_callback, rhs.m_callback ); 7188 std::swap( m_allocator, rhs.m_allocator ); 7189 std::swap( m_dispatcher, rhs.m_dispatcher ); 7190 } 7191 7192 private: 7193 VULKAN_HPP_NAMESPACE::Instance m_instance = {}; 7194 VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_callback = {}; 7195 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 7196 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 7197 }; 7198 7199 class DebugUtilsMessengerEXT 7200 { 7201 public: 7202 using CType = VkDebugUtilsMessengerEXT; 7203 using CppType = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT; 7204 7205 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT; 7206 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7207 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 7208 7209 public: 7210 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)7211 DebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 7212 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo, 7213 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7214 { 7215 *this = instance.createDebugUtilsMessengerEXT( createInfo, allocator ); 7216 } 7217 # endif 7218 DebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VkDebugUtilsMessengerEXT messenger,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7219 DebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 7220 VkDebugUtilsMessengerEXT messenger, 7221 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7222 : m_instance( instance ) 7223 , m_messenger( messenger ) 7224 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7225 , m_dispatcher( instance.getDispatcher() ) 7226 { 7227 } 7228 DebugUtilsMessengerEXT(std::nullptr_t)7229 DebugUtilsMessengerEXT( std::nullptr_t ) {} 7230 ~DebugUtilsMessengerEXT()7231 ~DebugUtilsMessengerEXT() 7232 { 7233 clear(); 7234 } 7235 7236 DebugUtilsMessengerEXT() = delete; 7237 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & ) = delete; 7238 DebugUtilsMessengerEXT(DebugUtilsMessengerEXT && rhs)7239 DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT 7240 : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) 7241 , m_messenger( VULKAN_HPP_NAMESPACE::exchange( rhs.m_messenger, {} ) ) 7242 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7243 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7244 { 7245 } 7246 7247 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & ) = delete; 7248 operator =(DebugUtilsMessengerEXT && rhs)7249 DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT 7250 { 7251 if ( this != &rhs ) 7252 { 7253 std::swap( m_instance, rhs.m_instance ); 7254 std::swap( m_messenger, rhs.m_messenger ); 7255 std::swap( m_allocator, rhs.m_allocator ); 7256 std::swap( m_dispatcher, rhs.m_dispatcher ); 7257 } 7258 return *this; 7259 } 7260 operator *() const7261 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const VULKAN_HPP_NOEXCEPT 7262 { 7263 return m_messenger; 7264 } 7265 operator VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT() const7266 operator VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT 7267 { 7268 return m_messenger; 7269 } 7270 clear()7271 void clear() VULKAN_HPP_NOEXCEPT 7272 { 7273 if ( m_messenger ) 7274 { 7275 getDispatcher()->vkDestroyDebugUtilsMessengerEXT( static_cast<VkInstance>( m_instance ), 7276 static_cast<VkDebugUtilsMessengerEXT>( m_messenger ), 7277 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7278 } 7279 m_instance = nullptr; 7280 m_messenger = nullptr; 7281 m_allocator = nullptr; 7282 m_dispatcher = nullptr; 7283 } 7284 release()7285 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT release() 7286 { 7287 m_instance = nullptr; 7288 m_allocator = nullptr; 7289 m_dispatcher = nullptr; 7290 return VULKAN_HPP_NAMESPACE::exchange( m_messenger, nullptr ); 7291 } 7292 getInstance() const7293 VULKAN_HPP_NAMESPACE::Instance getInstance() const 7294 { 7295 return m_instance; 7296 } 7297 getDispatcher() const7298 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 7299 { 7300 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7301 return m_dispatcher; 7302 } 7303 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT & rhs)7304 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT & rhs ) VULKAN_HPP_NOEXCEPT 7305 { 7306 std::swap( m_instance, rhs.m_instance ); 7307 std::swap( m_messenger, rhs.m_messenger ); 7308 std::swap( m_allocator, rhs.m_allocator ); 7309 std::swap( m_dispatcher, rhs.m_dispatcher ); 7310 } 7311 7312 private: 7313 VULKAN_HPP_NAMESPACE::Instance m_instance = {}; 7314 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_messenger = {}; 7315 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 7316 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 7317 }; 7318 7319 class DeferredOperationKHR 7320 { 7321 public: 7322 using CType = VkDeferredOperationKHR; 7323 using CppType = VULKAN_HPP_NAMESPACE::DeferredOperationKHR; 7324 7325 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR; 7326 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7327 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 7328 7329 public: 7330 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) DeferredOperationKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7331 DeferredOperationKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7332 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7333 { 7334 *this = device.createDeferredOperationKHR( allocator ); 7335 } 7336 # endif 7337 DeferredOperationKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDeferredOperationKHR operation,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7338 DeferredOperationKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7339 VkDeferredOperationKHR operation, 7340 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7341 : m_device( device ) 7342 , m_operation( operation ) 7343 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7344 , m_dispatcher( device.getDispatcher() ) 7345 { 7346 } 7347 DeferredOperationKHR(std::nullptr_t)7348 DeferredOperationKHR( std::nullptr_t ) {} 7349 ~DeferredOperationKHR()7350 ~DeferredOperationKHR() 7351 { 7352 clear(); 7353 } 7354 7355 DeferredOperationKHR() = delete; 7356 DeferredOperationKHR( DeferredOperationKHR const & ) = delete; 7357 DeferredOperationKHR(DeferredOperationKHR && rhs)7358 DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT 7359 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 7360 , m_operation( VULKAN_HPP_NAMESPACE::exchange( rhs.m_operation, {} ) ) 7361 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7362 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7363 { 7364 } 7365 7366 DeferredOperationKHR & operator=( DeferredOperationKHR const & ) = delete; 7367 operator =(DeferredOperationKHR && rhs)7368 DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT 7369 { 7370 if ( this != &rhs ) 7371 { 7372 std::swap( m_device, rhs.m_device ); 7373 std::swap( m_operation, rhs.m_operation ); 7374 std::swap( m_allocator, rhs.m_allocator ); 7375 std::swap( m_dispatcher, rhs.m_dispatcher ); 7376 } 7377 return *this; 7378 } 7379 operator *() const7380 VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const VULKAN_HPP_NOEXCEPT 7381 { 7382 return m_operation; 7383 } 7384 operator VULKAN_HPP_NAMESPACE::DeferredOperationKHR() const7385 operator VULKAN_HPP_NAMESPACE::DeferredOperationKHR() const VULKAN_HPP_NOEXCEPT 7386 { 7387 return m_operation; 7388 } 7389 clear()7390 void clear() VULKAN_HPP_NOEXCEPT 7391 { 7392 if ( m_operation ) 7393 { 7394 getDispatcher()->vkDestroyDeferredOperationKHR( static_cast<VkDevice>( m_device ), 7395 static_cast<VkDeferredOperationKHR>( m_operation ), 7396 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7397 } 7398 m_device = nullptr; 7399 m_operation = nullptr; 7400 m_allocator = nullptr; 7401 m_dispatcher = nullptr; 7402 } 7403 release()7404 VULKAN_HPP_NAMESPACE::DeferredOperationKHR release() 7405 { 7406 m_device = nullptr; 7407 m_allocator = nullptr; 7408 m_dispatcher = nullptr; 7409 return VULKAN_HPP_NAMESPACE::exchange( m_operation, nullptr ); 7410 } 7411 getDevice() const7412 VULKAN_HPP_NAMESPACE::Device getDevice() const 7413 { 7414 return m_device; 7415 } 7416 getDispatcher() const7417 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7418 { 7419 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7420 return m_dispatcher; 7421 } 7422 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR & rhs)7423 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR & rhs ) VULKAN_HPP_NOEXCEPT 7424 { 7425 std::swap( m_device, rhs.m_device ); 7426 std::swap( m_operation, rhs.m_operation ); 7427 std::swap( m_allocator, rhs.m_allocator ); 7428 std::swap( m_dispatcher, rhs.m_dispatcher ); 7429 } 7430 7431 //=== VK_KHR_deferred_host_operations === 7432 7433 VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT; 7434 7435 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getResult() const VULKAN_HPP_NOEXCEPT; 7436 7437 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result join() const; 7438 7439 private: 7440 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7441 VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_operation = {}; 7442 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 7443 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7444 }; 7445 7446 class DescriptorPool 7447 { 7448 public: 7449 using CType = VkDescriptorPool; 7450 using CppType = VULKAN_HPP_NAMESPACE::DescriptorPool; 7451 7452 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool; 7453 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7454 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool; 7455 7456 public: 7457 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)7458 DescriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7459 VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo, 7460 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7461 { 7462 *this = device.createDescriptorPool( createInfo, allocator ); 7463 } 7464 # endif 7465 DescriptorPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDescriptorPool descriptorPool,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7466 DescriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7467 VkDescriptorPool descriptorPool, 7468 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7469 : m_device( device ) 7470 , m_descriptorPool( descriptorPool ) 7471 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7472 , m_dispatcher( device.getDispatcher() ) 7473 { 7474 } 7475 DescriptorPool(std::nullptr_t)7476 DescriptorPool( std::nullptr_t ) {} 7477 ~DescriptorPool()7478 ~DescriptorPool() 7479 { 7480 clear(); 7481 } 7482 7483 DescriptorPool() = delete; 7484 DescriptorPool( DescriptorPool const & ) = delete; 7485 DescriptorPool(DescriptorPool && rhs)7486 DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT 7487 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 7488 , m_descriptorPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) 7489 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7490 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7491 { 7492 } 7493 7494 DescriptorPool & operator=( DescriptorPool const & ) = delete; 7495 operator =(DescriptorPool && rhs)7496 DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT 7497 { 7498 if ( this != &rhs ) 7499 { 7500 std::swap( m_device, rhs.m_device ); 7501 std::swap( m_descriptorPool, rhs.m_descriptorPool ); 7502 std::swap( m_allocator, rhs.m_allocator ); 7503 std::swap( m_dispatcher, rhs.m_dispatcher ); 7504 } 7505 return *this; 7506 } 7507 operator *() const7508 VULKAN_HPP_NAMESPACE::DescriptorPool const & operator*() const VULKAN_HPP_NOEXCEPT 7509 { 7510 return m_descriptorPool; 7511 } 7512 operator VULKAN_HPP_NAMESPACE::DescriptorPool() const7513 operator VULKAN_HPP_NAMESPACE::DescriptorPool() const VULKAN_HPP_NOEXCEPT 7514 { 7515 return m_descriptorPool; 7516 } 7517 clear()7518 void clear() VULKAN_HPP_NOEXCEPT 7519 { 7520 if ( m_descriptorPool ) 7521 { 7522 getDispatcher()->vkDestroyDescriptorPool( static_cast<VkDevice>( m_device ), 7523 static_cast<VkDescriptorPool>( m_descriptorPool ), 7524 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7525 } 7526 m_device = nullptr; 7527 m_descriptorPool = nullptr; 7528 m_allocator = nullptr; 7529 m_dispatcher = nullptr; 7530 } 7531 release()7532 VULKAN_HPP_NAMESPACE::DescriptorPool release() 7533 { 7534 m_device = nullptr; 7535 m_allocator = nullptr; 7536 m_dispatcher = nullptr; 7537 return VULKAN_HPP_NAMESPACE::exchange( m_descriptorPool, nullptr ); 7538 } 7539 getDevice() const7540 VULKAN_HPP_NAMESPACE::Device getDevice() const 7541 { 7542 return m_device; 7543 } 7544 getDispatcher() const7545 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7546 { 7547 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7548 return m_dispatcher; 7549 } 7550 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool & rhs)7551 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool & rhs ) VULKAN_HPP_NOEXCEPT 7552 { 7553 std::swap( m_device, rhs.m_device ); 7554 std::swap( m_descriptorPool, rhs.m_descriptorPool ); 7555 std::swap( m_allocator, rhs.m_allocator ); 7556 std::swap( m_dispatcher, rhs.m_dispatcher ); 7557 } 7558 7559 //=== VK_VERSION_1_0 === 7560 7561 void reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; 7562 7563 private: 7564 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7565 VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; 7566 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 7567 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7568 }; 7569 7570 class DescriptorSet 7571 { 7572 public: 7573 using CType = VkDescriptorSet; 7574 using CppType = VULKAN_HPP_NAMESPACE::DescriptorSet; 7575 7576 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet; 7577 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7578 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet; 7579 7580 public: DescriptorSet(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDescriptorSet descriptorSet,VkDescriptorPool descriptorPool)7581 DescriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool ) 7582 : m_device( device ), m_descriptorPool( descriptorPool ), m_descriptorSet( descriptorSet ), m_dispatcher( device.getDispatcher() ) 7583 { 7584 } 7585 DescriptorSet(std::nullptr_t)7586 DescriptorSet( std::nullptr_t ) {} 7587 ~DescriptorSet()7588 ~DescriptorSet() 7589 { 7590 clear(); 7591 } 7592 7593 DescriptorSet() = delete; 7594 DescriptorSet( DescriptorSet const & ) = delete; 7595 DescriptorSet(DescriptorSet && rhs)7596 DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT 7597 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 7598 , m_descriptorPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) ) 7599 , m_descriptorSet( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) ) 7600 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7601 { 7602 } 7603 7604 DescriptorSet & operator=( DescriptorSet const & ) = delete; 7605 operator =(DescriptorSet && rhs)7606 DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT 7607 { 7608 if ( this != &rhs ) 7609 { 7610 std::swap( m_device, rhs.m_device ); 7611 std::swap( m_descriptorPool, rhs.m_descriptorPool ); 7612 std::swap( m_descriptorSet, rhs.m_descriptorSet ); 7613 std::swap( m_dispatcher, rhs.m_dispatcher ); 7614 } 7615 return *this; 7616 } 7617 operator *() const7618 VULKAN_HPP_NAMESPACE::DescriptorSet const & operator*() const VULKAN_HPP_NOEXCEPT 7619 { 7620 return m_descriptorSet; 7621 } 7622 operator VULKAN_HPP_NAMESPACE::DescriptorSet() const7623 operator VULKAN_HPP_NAMESPACE::DescriptorSet() const VULKAN_HPP_NOEXCEPT 7624 { 7625 return m_descriptorSet; 7626 } 7627 clear()7628 void clear() VULKAN_HPP_NOEXCEPT 7629 { 7630 if ( m_descriptorSet ) 7631 { 7632 getDispatcher()->vkFreeDescriptorSets( static_cast<VkDevice>( m_device ), 7633 static_cast<VkDescriptorPool>( m_descriptorPool ), 7634 1, 7635 reinterpret_cast<VkDescriptorSet const *>( &m_descriptorSet ) ); 7636 } 7637 m_device = nullptr; 7638 m_descriptorPool = nullptr; 7639 m_descriptorSet = nullptr; 7640 m_dispatcher = nullptr; 7641 } 7642 release()7643 VULKAN_HPP_NAMESPACE::DescriptorSet release() 7644 { 7645 m_device = nullptr; 7646 m_descriptorPool = nullptr; 7647 m_dispatcher = nullptr; 7648 return VULKAN_HPP_NAMESPACE::exchange( m_descriptorSet, nullptr ); 7649 } 7650 getDevice() const7651 VULKAN_HPP_NAMESPACE::Device getDevice() const 7652 { 7653 return m_device; 7654 } 7655 getDispatcher() const7656 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7657 { 7658 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7659 return m_dispatcher; 7660 } 7661 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet & rhs)7662 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet & rhs ) VULKAN_HPP_NOEXCEPT 7663 { 7664 std::swap( m_device, rhs.m_device ); 7665 std::swap( m_descriptorPool, rhs.m_descriptorPool ); 7666 std::swap( m_descriptorSet, rhs.m_descriptorSet ); 7667 std::swap( m_dispatcher, rhs.m_dispatcher ); 7668 } 7669 7670 //=== VK_VERSION_1_1 === 7671 7672 template <typename DataType> 7673 void updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT; 7674 7675 //=== VK_KHR_descriptor_update_template === 7676 7677 template <typename DataType> 7678 void updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT; 7679 7680 //=== VK_VALVE_descriptor_set_host_mapping === 7681 7682 VULKAN_HPP_NODISCARD void * getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT; 7683 7684 private: 7685 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7686 VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; 7687 VULKAN_HPP_NAMESPACE::DescriptorSet m_descriptorSet = {}; 7688 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7689 }; 7690 7691 class DescriptorSets : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> 7692 { 7693 public: 7694 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) DescriptorSets(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo)7695 DescriptorSets( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7696 VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) 7697 { 7698 *this = device.allocateDescriptorSets( allocateInfo ); 7699 } 7700 # endif 7701 DescriptorSets(std::nullptr_t)7702 DescriptorSets( std::nullptr_t ) {} 7703 7704 DescriptorSets() = delete; 7705 DescriptorSets( DescriptorSets const & ) = delete; 7706 DescriptorSets( DescriptorSets && rhs ) = default; 7707 DescriptorSets & operator=( DescriptorSets const & ) = delete; 7708 DescriptorSets & operator=( DescriptorSets && rhs ) = default; 7709 7710 private: DescriptorSets(std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> && rhs)7711 DescriptorSets( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> && rhs ) 7712 { 7713 std::swap( *this, rhs ); 7714 } 7715 }; 7716 7717 class DescriptorSetLayout 7718 { 7719 public: 7720 using CType = VkDescriptorSetLayout; 7721 using CppType = VULKAN_HPP_NAMESPACE::DescriptorSetLayout; 7722 7723 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout; 7724 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7725 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout; 7726 7727 public: 7728 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)7729 DescriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7730 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo, 7731 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7732 { 7733 *this = device.createDescriptorSetLayout( createInfo, allocator ); 7734 } 7735 # endif 7736 DescriptorSetLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDescriptorSetLayout descriptorSetLayout,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7737 DescriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7738 VkDescriptorSetLayout descriptorSetLayout, 7739 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7740 : m_device( device ) 7741 , m_descriptorSetLayout( descriptorSetLayout ) 7742 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7743 , m_dispatcher( device.getDispatcher() ) 7744 { 7745 } 7746 DescriptorSetLayout(std::nullptr_t)7747 DescriptorSetLayout( std::nullptr_t ) {} 7748 ~DescriptorSetLayout()7749 ~DescriptorSetLayout() 7750 { 7751 clear(); 7752 } 7753 7754 DescriptorSetLayout() = delete; 7755 DescriptorSetLayout( DescriptorSetLayout const & ) = delete; 7756 DescriptorSetLayout(DescriptorSetLayout && rhs)7757 DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT 7758 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 7759 , m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) ) 7760 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7761 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7762 { 7763 } 7764 7765 DescriptorSetLayout & operator=( DescriptorSetLayout const & ) = delete; 7766 operator =(DescriptorSetLayout && rhs)7767 DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT 7768 { 7769 if ( this != &rhs ) 7770 { 7771 std::swap( m_device, rhs.m_device ); 7772 std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout ); 7773 std::swap( m_allocator, rhs.m_allocator ); 7774 std::swap( m_dispatcher, rhs.m_dispatcher ); 7775 } 7776 return *this; 7777 } 7778 operator *() const7779 VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & operator*() const VULKAN_HPP_NOEXCEPT 7780 { 7781 return m_descriptorSetLayout; 7782 } 7783 operator VULKAN_HPP_NAMESPACE::DescriptorSetLayout() const7784 operator VULKAN_HPP_NAMESPACE::DescriptorSetLayout() const VULKAN_HPP_NOEXCEPT 7785 { 7786 return m_descriptorSetLayout; 7787 } 7788 clear()7789 void clear() VULKAN_HPP_NOEXCEPT 7790 { 7791 if ( m_descriptorSetLayout ) 7792 { 7793 getDispatcher()->vkDestroyDescriptorSetLayout( static_cast<VkDevice>( m_device ), 7794 static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ), 7795 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7796 } 7797 m_device = nullptr; 7798 m_descriptorSetLayout = nullptr; 7799 m_allocator = nullptr; 7800 m_dispatcher = nullptr; 7801 } 7802 release()7803 VULKAN_HPP_NAMESPACE::DescriptorSetLayout release() 7804 { 7805 m_device = nullptr; 7806 m_allocator = nullptr; 7807 m_dispatcher = nullptr; 7808 return VULKAN_HPP_NAMESPACE::exchange( m_descriptorSetLayout, nullptr ); 7809 } 7810 getDevice() const7811 VULKAN_HPP_NAMESPACE::Device getDevice() const 7812 { 7813 return m_device; 7814 } 7815 getDispatcher() const7816 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7817 { 7818 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7819 return m_dispatcher; 7820 } 7821 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout & rhs)7822 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout & rhs ) VULKAN_HPP_NOEXCEPT 7823 { 7824 std::swap( m_device, rhs.m_device ); 7825 std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout ); 7826 std::swap( m_allocator, rhs.m_allocator ); 7827 std::swap( m_dispatcher, rhs.m_dispatcher ); 7828 } 7829 7830 //=== VK_EXT_descriptor_buffer === 7831 7832 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getSizeEXT() const VULKAN_HPP_NOEXCEPT; 7833 7834 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT; 7835 7836 private: 7837 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7838 VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout = {}; 7839 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 7840 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7841 }; 7842 7843 class DescriptorUpdateTemplate 7844 { 7845 public: 7846 using CType = VkDescriptorUpdateTemplate; 7847 using CppType = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate; 7848 7849 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate; 7850 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7851 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; 7852 7853 public: 7854 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)7855 DescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7856 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 7857 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7858 { 7859 *this = device.createDescriptorUpdateTemplate( createInfo, allocator ); 7860 } 7861 # endif 7862 DescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDescriptorUpdateTemplate descriptorUpdateTemplate,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7863 DescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7864 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 7865 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7866 : m_device( device ) 7867 , m_descriptorUpdateTemplate( descriptorUpdateTemplate ) 7868 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7869 , m_dispatcher( device.getDispatcher() ) 7870 { 7871 } 7872 DescriptorUpdateTemplate(std::nullptr_t)7873 DescriptorUpdateTemplate( std::nullptr_t ) {} 7874 ~DescriptorUpdateTemplate()7875 ~DescriptorUpdateTemplate() 7876 { 7877 clear(); 7878 } 7879 7880 DescriptorUpdateTemplate() = delete; 7881 DescriptorUpdateTemplate( DescriptorUpdateTemplate const & ) = delete; 7882 DescriptorUpdateTemplate(DescriptorUpdateTemplate && rhs)7883 DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT 7884 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 7885 , m_descriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ) ) 7886 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 7887 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 7888 { 7889 } 7890 7891 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & ) = delete; 7892 operator =(DescriptorUpdateTemplate && rhs)7893 DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT 7894 { 7895 if ( this != &rhs ) 7896 { 7897 std::swap( m_device, rhs.m_device ); 7898 std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate ); 7899 std::swap( m_allocator, rhs.m_allocator ); 7900 std::swap( m_dispatcher, rhs.m_dispatcher ); 7901 } 7902 return *this; 7903 } 7904 operator *() const7905 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & operator*() const VULKAN_HPP_NOEXCEPT 7906 { 7907 return m_descriptorUpdateTemplate; 7908 } 7909 operator VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate() const7910 operator VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT 7911 { 7912 return m_descriptorUpdateTemplate; 7913 } 7914 clear()7915 void clear() VULKAN_HPP_NOEXCEPT 7916 { 7917 if ( m_descriptorUpdateTemplate ) 7918 { 7919 getDispatcher()->vkDestroyDescriptorUpdateTemplate( static_cast<VkDevice>( m_device ), 7920 static_cast<VkDescriptorUpdateTemplate>( m_descriptorUpdateTemplate ), 7921 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 7922 } 7923 m_device = nullptr; 7924 m_descriptorUpdateTemplate = nullptr; 7925 m_allocator = nullptr; 7926 m_dispatcher = nullptr; 7927 } 7928 release()7929 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate release() 7930 { 7931 m_device = nullptr; 7932 m_allocator = nullptr; 7933 m_dispatcher = nullptr; 7934 return VULKAN_HPP_NAMESPACE::exchange( m_descriptorUpdateTemplate, nullptr ); 7935 } 7936 getDevice() const7937 VULKAN_HPP_NAMESPACE::Device getDevice() const 7938 { 7939 return m_device; 7940 } 7941 getDispatcher() const7942 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 7943 { 7944 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 7945 return m_dispatcher; 7946 } 7947 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate & rhs)7948 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate & rhs ) VULKAN_HPP_NOEXCEPT 7949 { 7950 std::swap( m_device, rhs.m_device ); 7951 std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate ); 7952 std::swap( m_allocator, rhs.m_allocator ); 7953 std::swap( m_dispatcher, rhs.m_dispatcher ); 7954 } 7955 7956 private: 7957 VULKAN_HPP_NAMESPACE::Device m_device = {}; 7958 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; 7959 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 7960 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 7961 }; 7962 7963 class DeviceMemory 7964 { 7965 public: 7966 using CType = VkDeviceMemory; 7967 using CppType = VULKAN_HPP_NAMESPACE::DeviceMemory; 7968 7969 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory; 7970 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 7971 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory; 7972 7973 public: 7974 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)7975 DeviceMemory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7976 VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo, 7977 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7978 { 7979 *this = device.allocateMemory( allocateInfo, allocator ); 7980 } 7981 # endif 7982 DeviceMemory(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkDeviceMemory memory,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)7983 DeviceMemory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 7984 VkDeviceMemory memory, 7985 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 7986 : m_device( device ) 7987 , m_memory( memory ) 7988 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 7989 , m_dispatcher( device.getDispatcher() ) 7990 { 7991 } 7992 DeviceMemory(std::nullptr_t)7993 DeviceMemory( std::nullptr_t ) {} 7994 ~DeviceMemory()7995 ~DeviceMemory() 7996 { 7997 clear(); 7998 } 7999 8000 DeviceMemory() = delete; 8001 DeviceMemory( DeviceMemory const & ) = delete; 8002 DeviceMemory(DeviceMemory && rhs)8003 DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT 8004 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 8005 , m_memory( VULKAN_HPP_NAMESPACE::exchange( rhs.m_memory, {} ) ) 8006 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8007 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8008 { 8009 } 8010 8011 DeviceMemory & operator=( DeviceMemory const & ) = delete; 8012 operator =(DeviceMemory && rhs)8013 DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT 8014 { 8015 if ( this != &rhs ) 8016 { 8017 std::swap( m_device, rhs.m_device ); 8018 std::swap( m_memory, rhs.m_memory ); 8019 std::swap( m_allocator, rhs.m_allocator ); 8020 std::swap( m_dispatcher, rhs.m_dispatcher ); 8021 } 8022 return *this; 8023 } 8024 operator *() const8025 VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const VULKAN_HPP_NOEXCEPT 8026 { 8027 return m_memory; 8028 } 8029 operator VULKAN_HPP_NAMESPACE::DeviceMemory() const8030 operator VULKAN_HPP_NAMESPACE::DeviceMemory() const VULKAN_HPP_NOEXCEPT 8031 { 8032 return m_memory; 8033 } 8034 clear()8035 void clear() VULKAN_HPP_NOEXCEPT 8036 { 8037 if ( m_memory ) 8038 { 8039 getDispatcher()->vkFreeMemory( 8040 static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8041 } 8042 m_device = nullptr; 8043 m_memory = nullptr; 8044 m_allocator = nullptr; 8045 m_dispatcher = nullptr; 8046 } 8047 release()8048 VULKAN_HPP_NAMESPACE::DeviceMemory release() 8049 { 8050 m_device = nullptr; 8051 m_allocator = nullptr; 8052 m_dispatcher = nullptr; 8053 return VULKAN_HPP_NAMESPACE::exchange( m_memory, nullptr ); 8054 } 8055 getDevice() const8056 VULKAN_HPP_NAMESPACE::Device getDevice() const 8057 { 8058 return m_device; 8059 } 8060 getDispatcher() const8061 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8062 { 8063 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8064 return m_dispatcher; 8065 } 8066 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory & rhs)8067 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory & rhs ) VULKAN_HPP_NOEXCEPT 8068 { 8069 std::swap( m_device, rhs.m_device ); 8070 std::swap( m_memory, rhs.m_memory ); 8071 std::swap( m_allocator, rhs.m_allocator ); 8072 std::swap( m_dispatcher, rhs.m_dispatcher ); 8073 } 8074 8075 //=== VK_VERSION_1_0 === 8076 8077 VULKAN_HPP_NODISCARD void * mapMemory( VULKAN_HPP_NAMESPACE::DeviceSize offset, 8078 VULKAN_HPP_NAMESPACE::DeviceSize size, 8079 VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 8080 8081 void unmapMemory() const VULKAN_HPP_NOEXCEPT; 8082 8083 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getCommitment() const VULKAN_HPP_NOEXCEPT; 8084 8085 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 8086 //=== VK_NV_external_memory_win32 === 8087 8088 VULKAN_HPP_NODISCARD HANDLE getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const; 8089 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 8090 8091 //=== VK_EXT_pageable_device_local_memory === 8092 8093 void setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT; 8094 8095 private: 8096 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8097 VULKAN_HPP_NAMESPACE::DeviceMemory m_memory = {}; 8098 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 8099 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8100 }; 8101 8102 class DisplayKHR 8103 { 8104 public: 8105 using CType = VkDisplayKHR; 8106 using CppType = VULKAN_HPP_NAMESPACE::DisplayKHR; 8107 8108 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR; 8109 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8110 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR; 8111 8112 public: 8113 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,int32_t drmFd,uint32_t connectorId)8114 DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, int32_t drmFd, uint32_t connectorId ) 8115 { 8116 *this = physicalDevice.getDrmDisplayEXT( drmFd, connectorId ); 8117 } 8118 # endif 8119 8120 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 8121 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,Display & dpy,RROutput rrOutput)8122 DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, Display & dpy, RROutput rrOutput ) 8123 { 8124 *this = physicalDevice.getRandROutputDisplayEXT( dpy, rrOutput ); 8125 } 8126 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 8127 # endif 8128 8129 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 8130 # if defined( VK_USE_PLATFORM_WIN32_KHR ) DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,uint32_t deviceRelativeId)8131 DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, uint32_t deviceRelativeId ) 8132 { 8133 *this = physicalDevice.getWinrtDisplayNV( deviceRelativeId ); 8134 } 8135 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 8136 # endif 8137 DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,VkDisplayKHR display)8138 DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, VkDisplayKHR display ) 8139 : m_physicalDevice( physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() ) 8140 { 8141 } 8142 DisplayKHR(std::nullptr_t)8143 DisplayKHR( std::nullptr_t ) {} 8144 ~DisplayKHR()8145 ~DisplayKHR() 8146 { 8147 clear(); 8148 } 8149 8150 DisplayKHR() = delete; 8151 DisplayKHR( DisplayKHR const & ) = delete; 8152 DisplayKHR(DisplayKHR && rhs)8153 DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT 8154 : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) 8155 , m_display( VULKAN_HPP_NAMESPACE::exchange( rhs.m_display, {} ) ) 8156 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8157 { 8158 } 8159 8160 DisplayKHR & operator=( DisplayKHR const & ) = delete; 8161 operator =(DisplayKHR && rhs)8162 DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT 8163 { 8164 if ( this != &rhs ) 8165 { 8166 std::swap( m_physicalDevice, rhs.m_physicalDevice ); 8167 std::swap( m_display, rhs.m_display ); 8168 std::swap( m_dispatcher, rhs.m_dispatcher ); 8169 } 8170 return *this; 8171 } 8172 operator *() const8173 VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const VULKAN_HPP_NOEXCEPT 8174 { 8175 return m_display; 8176 } 8177 operator VULKAN_HPP_NAMESPACE::DisplayKHR() const8178 operator VULKAN_HPP_NAMESPACE::DisplayKHR() const VULKAN_HPP_NOEXCEPT 8179 { 8180 return m_display; 8181 } 8182 clear()8183 void clear() VULKAN_HPP_NOEXCEPT 8184 { 8185 if ( m_display ) 8186 { 8187 getDispatcher()->vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) ); 8188 } 8189 m_physicalDevice = nullptr; 8190 m_display = nullptr; 8191 m_dispatcher = nullptr; 8192 } 8193 release()8194 VULKAN_HPP_NAMESPACE::DisplayKHR release() 8195 { 8196 m_physicalDevice = nullptr; 8197 m_dispatcher = nullptr; 8198 return VULKAN_HPP_NAMESPACE::exchange( m_display, nullptr ); 8199 } 8200 getPhysicalDevice() const8201 VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const 8202 { 8203 return m_physicalDevice; 8204 } 8205 getDispatcher() const8206 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 8207 { 8208 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8209 return m_dispatcher; 8210 } 8211 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR & rhs)8212 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR & rhs ) VULKAN_HPP_NOEXCEPT 8213 { 8214 std::swap( m_physicalDevice, rhs.m_physicalDevice ); 8215 std::swap( m_display, rhs.m_display ); 8216 std::swap( m_dispatcher, rhs.m_dispatcher ); 8217 } 8218 8219 //=== VK_KHR_display === 8220 8221 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const; 8222 8223 VULKAN_HPP_NODISCARD 8224 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR>::Type 8225 createMode( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, 8226 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT; 8227 8228 //=== VK_KHR_get_display_properties2 === 8229 8230 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const; 8231 8232 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 8233 //=== VK_NV_acquire_winrt_display === 8234 8235 void acquireWinrtNV() const; 8236 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 8237 8238 private: 8239 VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; 8240 VULKAN_HPP_NAMESPACE::DisplayKHR m_display = {}; 8241 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 8242 }; 8243 8244 class DisplayKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> 8245 { 8246 public: 8247 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) DisplayKHRs(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,uint32_t planeIndex)8248 DisplayKHRs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, uint32_t planeIndex ) 8249 { 8250 *this = physicalDevice.getDisplayPlaneSupportedDisplaysKHR( planeIndex ); 8251 } 8252 # endif 8253 DisplayKHRs(std::nullptr_t)8254 DisplayKHRs( std::nullptr_t ) {} 8255 8256 DisplayKHRs() = delete; 8257 DisplayKHRs( DisplayKHRs const & ) = delete; 8258 DisplayKHRs( DisplayKHRs && rhs ) = default; 8259 DisplayKHRs & operator=( DisplayKHRs const & ) = delete; 8260 DisplayKHRs & operator=( DisplayKHRs && rhs ) = default; 8261 8262 private: DisplayKHRs(std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> && rhs)8263 DisplayKHRs( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> && rhs ) 8264 { 8265 std::swap( *this, rhs ); 8266 } 8267 }; 8268 8269 class DisplayModeKHR 8270 { 8271 public: 8272 using CType = VkDisplayModeKHR; 8273 using CppType = VULKAN_HPP_NAMESPACE::DisplayModeKHR; 8274 8275 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR; 8276 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8277 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR; 8278 8279 public: 8280 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)8281 DisplayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, 8282 VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, 8283 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8284 { 8285 *this = display.createMode( createInfo, allocator ); 8286 } 8287 # endif 8288 DisplayModeKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,VkDisplayModeKHR displayModeKHR)8289 DisplayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, VkDisplayModeKHR displayModeKHR ) 8290 : m_physicalDevice( display.getPhysicalDevice() ), m_displayModeKHR( displayModeKHR ), m_dispatcher( display.getDispatcher() ) 8291 { 8292 } 8293 DisplayModeKHR(std::nullptr_t)8294 DisplayModeKHR( std::nullptr_t ) {} 8295 ~DisplayModeKHR()8296 ~DisplayModeKHR() 8297 { 8298 clear(); 8299 } 8300 8301 DisplayModeKHR() = delete; 8302 DisplayModeKHR(DisplayModeKHR const & rhs)8303 DisplayModeKHR( DisplayModeKHR const & rhs ) : m_displayModeKHR( rhs.m_displayModeKHR ), m_dispatcher( rhs.m_dispatcher ) {} 8304 DisplayModeKHR(DisplayModeKHR && rhs)8305 DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT 8306 : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) 8307 , m_displayModeKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) ) 8308 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8309 { 8310 } 8311 operator =(DisplayModeKHR const & rhs)8312 DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) 8313 { 8314 m_displayModeKHR = rhs.m_displayModeKHR; 8315 m_dispatcher = rhs.m_dispatcher; 8316 return *this; 8317 } 8318 operator =(DisplayModeKHR && rhs)8319 DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT 8320 { 8321 if ( this != &rhs ) 8322 { 8323 std::swap( m_physicalDevice, rhs.m_physicalDevice ); 8324 std::swap( m_displayModeKHR, rhs.m_displayModeKHR ); 8325 std::swap( m_dispatcher, rhs.m_dispatcher ); 8326 } 8327 return *this; 8328 } 8329 operator *() const8330 VULKAN_HPP_NAMESPACE::DisplayModeKHR const & operator*() const VULKAN_HPP_NOEXCEPT 8331 { 8332 return m_displayModeKHR; 8333 } 8334 operator VULKAN_HPP_NAMESPACE::DisplayModeKHR() const8335 operator VULKAN_HPP_NAMESPACE::DisplayModeKHR() const VULKAN_HPP_NOEXCEPT 8336 { 8337 return m_displayModeKHR; 8338 } 8339 clear()8340 void clear() VULKAN_HPP_NOEXCEPT 8341 { 8342 m_physicalDevice = nullptr; 8343 m_displayModeKHR = nullptr; 8344 m_dispatcher = nullptr; 8345 } 8346 release()8347 VULKAN_HPP_NAMESPACE::DisplayModeKHR release() 8348 { 8349 m_physicalDevice = nullptr; 8350 m_dispatcher = nullptr; 8351 return VULKAN_HPP_NAMESPACE::exchange( m_displayModeKHR, nullptr ); 8352 } 8353 getDispatcher() const8354 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 8355 { 8356 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8357 return m_dispatcher; 8358 } 8359 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR & rhs)8360 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR & rhs ) VULKAN_HPP_NOEXCEPT 8361 { 8362 std::swap( m_physicalDevice, rhs.m_physicalDevice ); 8363 std::swap( m_displayModeKHR, rhs.m_displayModeKHR ); 8364 std::swap( m_dispatcher, rhs.m_dispatcher ); 8365 } 8366 8367 //=== VK_KHR_display === 8368 8369 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR getDisplayPlaneCapabilities( uint32_t planeIndex ) const; 8370 8371 private: 8372 VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; 8373 VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR = {}; 8374 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 8375 }; 8376 8377 class Event 8378 { 8379 public: 8380 using CType = VkEvent; 8381 using CppType = VULKAN_HPP_NAMESPACE::Event; 8382 8383 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent; 8384 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8385 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent; 8386 8387 public: 8388 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)8389 Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8390 VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo, 8391 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8392 { 8393 *this = device.createEvent( createInfo, allocator ); 8394 } 8395 # endif 8396 Event(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkEvent event,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8397 Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8398 VkEvent event, 8399 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8400 : m_device( device ) 8401 , m_event( event ) 8402 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8403 , m_dispatcher( device.getDispatcher() ) 8404 { 8405 } 8406 Event(std::nullptr_t)8407 Event( std::nullptr_t ) {} 8408 ~Event()8409 ~Event() 8410 { 8411 clear(); 8412 } 8413 8414 Event() = delete; 8415 Event( Event const & ) = delete; 8416 Event(Event && rhs)8417 Event( Event && rhs ) VULKAN_HPP_NOEXCEPT 8418 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 8419 , m_event( VULKAN_HPP_NAMESPACE::exchange( rhs.m_event, {} ) ) 8420 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8421 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8422 { 8423 } 8424 8425 Event & operator=( Event const & ) = delete; 8426 operator =(Event && rhs)8427 Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT 8428 { 8429 if ( this != &rhs ) 8430 { 8431 std::swap( m_device, rhs.m_device ); 8432 std::swap( m_event, rhs.m_event ); 8433 std::swap( m_allocator, rhs.m_allocator ); 8434 std::swap( m_dispatcher, rhs.m_dispatcher ); 8435 } 8436 return *this; 8437 } 8438 operator *() const8439 VULKAN_HPP_NAMESPACE::Event const & operator*() const VULKAN_HPP_NOEXCEPT 8440 { 8441 return m_event; 8442 } 8443 operator VULKAN_HPP_NAMESPACE::Event() const8444 operator VULKAN_HPP_NAMESPACE::Event() const VULKAN_HPP_NOEXCEPT 8445 { 8446 return m_event; 8447 } 8448 clear()8449 void clear() VULKAN_HPP_NOEXCEPT 8450 { 8451 if ( m_event ) 8452 { 8453 getDispatcher()->vkDestroyEvent( 8454 static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8455 } 8456 m_device = nullptr; 8457 m_event = nullptr; 8458 m_allocator = nullptr; 8459 m_dispatcher = nullptr; 8460 } 8461 release()8462 VULKAN_HPP_NAMESPACE::Event release() 8463 { 8464 m_device = nullptr; 8465 m_allocator = nullptr; 8466 m_dispatcher = nullptr; 8467 return VULKAN_HPP_NAMESPACE::exchange( m_event, nullptr ); 8468 } 8469 getDevice() const8470 VULKAN_HPP_NAMESPACE::Device getDevice() const 8471 { 8472 return m_device; 8473 } 8474 getDispatcher() const8475 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8476 { 8477 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8478 return m_dispatcher; 8479 } 8480 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event & rhs)8481 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event & rhs ) VULKAN_HPP_NOEXCEPT 8482 { 8483 std::swap( m_device, rhs.m_device ); 8484 std::swap( m_event, rhs.m_event ); 8485 std::swap( m_allocator, rhs.m_allocator ); 8486 std::swap( m_dispatcher, rhs.m_dispatcher ); 8487 } 8488 8489 //=== VK_VERSION_1_0 === 8490 8491 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; 8492 8493 void set() const; 8494 8495 void reset() const; 8496 8497 private: 8498 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8499 VULKAN_HPP_NAMESPACE::Event m_event = {}; 8500 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 8501 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8502 }; 8503 8504 class Fence 8505 { 8506 public: 8507 using CType = VkFence; 8508 using CppType = VULKAN_HPP_NAMESPACE::Fence; 8509 8510 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence; 8511 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8512 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence; 8513 8514 public: 8515 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)8516 Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8517 VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo, 8518 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8519 { 8520 *this = device.createFence( createInfo, allocator ); 8521 } 8522 # endif 8523 8524 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)8525 Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8526 VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo, 8527 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8528 { 8529 *this = device.registerEventEXT( deviceEventInfo, allocator ); 8530 } 8531 # endif 8532 8533 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)8534 Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8535 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, 8536 VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo, 8537 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8538 { 8539 *this = device.registerDisplayEventEXT( display, displayEventInfo, allocator ); 8540 } 8541 # endif 8542 Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkFence fence,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8543 Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8544 VkFence fence, 8545 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8546 : m_device( device ) 8547 , m_fence( fence ) 8548 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8549 , m_dispatcher( device.getDispatcher() ) 8550 { 8551 } 8552 Fence(std::nullptr_t)8553 Fence( std::nullptr_t ) {} 8554 ~Fence()8555 ~Fence() 8556 { 8557 clear(); 8558 } 8559 8560 Fence() = delete; 8561 Fence( Fence const & ) = delete; 8562 Fence(Fence && rhs)8563 Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT 8564 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 8565 , m_fence( VULKAN_HPP_NAMESPACE::exchange( rhs.m_fence, {} ) ) 8566 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8567 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8568 { 8569 } 8570 8571 Fence & operator=( Fence const & ) = delete; 8572 operator =(Fence && rhs)8573 Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT 8574 { 8575 if ( this != &rhs ) 8576 { 8577 std::swap( m_device, rhs.m_device ); 8578 std::swap( m_fence, rhs.m_fence ); 8579 std::swap( m_allocator, rhs.m_allocator ); 8580 std::swap( m_dispatcher, rhs.m_dispatcher ); 8581 } 8582 return *this; 8583 } 8584 operator *() const8585 VULKAN_HPP_NAMESPACE::Fence const & operator*() const VULKAN_HPP_NOEXCEPT 8586 { 8587 return m_fence; 8588 } 8589 operator VULKAN_HPP_NAMESPACE::Fence() const8590 operator VULKAN_HPP_NAMESPACE::Fence() const VULKAN_HPP_NOEXCEPT 8591 { 8592 return m_fence; 8593 } 8594 clear()8595 void clear() VULKAN_HPP_NOEXCEPT 8596 { 8597 if ( m_fence ) 8598 { 8599 getDispatcher()->vkDestroyFence( 8600 static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8601 } 8602 m_device = nullptr; 8603 m_fence = nullptr; 8604 m_allocator = nullptr; 8605 m_dispatcher = nullptr; 8606 } 8607 release()8608 VULKAN_HPP_NAMESPACE::Fence release() 8609 { 8610 m_device = nullptr; 8611 m_allocator = nullptr; 8612 m_dispatcher = nullptr; 8613 return VULKAN_HPP_NAMESPACE::exchange( m_fence, nullptr ); 8614 } 8615 getDevice() const8616 VULKAN_HPP_NAMESPACE::Device getDevice() const 8617 { 8618 return m_device; 8619 } 8620 getDispatcher() const8621 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8622 { 8623 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8624 return m_dispatcher; 8625 } 8626 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence & rhs)8627 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence & rhs ) VULKAN_HPP_NOEXCEPT 8628 { 8629 std::swap( m_device, rhs.m_device ); 8630 std::swap( m_fence, rhs.m_fence ); 8631 std::swap( m_allocator, rhs.m_allocator ); 8632 std::swap( m_dispatcher, rhs.m_dispatcher ); 8633 } 8634 8635 //=== VK_VERSION_1_0 === 8636 8637 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; 8638 8639 private: 8640 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8641 VULKAN_HPP_NAMESPACE::Fence m_fence = {}; 8642 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 8643 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8644 }; 8645 8646 class Framebuffer 8647 { 8648 public: 8649 using CType = VkFramebuffer; 8650 using CppType = VULKAN_HPP_NAMESPACE::Framebuffer; 8651 8652 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer; 8653 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8654 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer; 8655 8656 public: 8657 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)8658 Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8659 VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo, 8660 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8661 { 8662 *this = device.createFramebuffer( createInfo, allocator ); 8663 } 8664 # endif 8665 Framebuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkFramebuffer framebuffer,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8666 Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8667 VkFramebuffer framebuffer, 8668 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8669 : m_device( device ) 8670 , m_framebuffer( framebuffer ) 8671 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8672 , m_dispatcher( device.getDispatcher() ) 8673 { 8674 } 8675 Framebuffer(std::nullptr_t)8676 Framebuffer( std::nullptr_t ) {} 8677 ~Framebuffer()8678 ~Framebuffer() 8679 { 8680 clear(); 8681 } 8682 8683 Framebuffer() = delete; 8684 Framebuffer( Framebuffer const & ) = delete; 8685 Framebuffer(Framebuffer && rhs)8686 Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT 8687 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 8688 , m_framebuffer( VULKAN_HPP_NAMESPACE::exchange( rhs.m_framebuffer, {} ) ) 8689 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8690 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8691 { 8692 } 8693 8694 Framebuffer & operator=( Framebuffer const & ) = delete; 8695 operator =(Framebuffer && rhs)8696 Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT 8697 { 8698 if ( this != &rhs ) 8699 { 8700 std::swap( m_device, rhs.m_device ); 8701 std::swap( m_framebuffer, rhs.m_framebuffer ); 8702 std::swap( m_allocator, rhs.m_allocator ); 8703 std::swap( m_dispatcher, rhs.m_dispatcher ); 8704 } 8705 return *this; 8706 } 8707 operator *() const8708 VULKAN_HPP_NAMESPACE::Framebuffer const & operator*() const VULKAN_HPP_NOEXCEPT 8709 { 8710 return m_framebuffer; 8711 } 8712 operator VULKAN_HPP_NAMESPACE::Framebuffer() const8713 operator VULKAN_HPP_NAMESPACE::Framebuffer() const VULKAN_HPP_NOEXCEPT 8714 { 8715 return m_framebuffer; 8716 } 8717 clear()8718 void clear() VULKAN_HPP_NOEXCEPT 8719 { 8720 if ( m_framebuffer ) 8721 { 8722 getDispatcher()->vkDestroyFramebuffer( 8723 static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( m_framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8724 } 8725 m_device = nullptr; 8726 m_framebuffer = nullptr; 8727 m_allocator = nullptr; 8728 m_dispatcher = nullptr; 8729 } 8730 release()8731 VULKAN_HPP_NAMESPACE::Framebuffer release() 8732 { 8733 m_device = nullptr; 8734 m_allocator = nullptr; 8735 m_dispatcher = nullptr; 8736 return VULKAN_HPP_NAMESPACE::exchange( m_framebuffer, nullptr ); 8737 } 8738 getDevice() const8739 VULKAN_HPP_NAMESPACE::Device getDevice() const 8740 { 8741 return m_device; 8742 } 8743 getDispatcher() const8744 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8745 { 8746 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8747 return m_dispatcher; 8748 } 8749 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer & rhs)8750 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer & rhs ) VULKAN_HPP_NOEXCEPT 8751 { 8752 std::swap( m_device, rhs.m_device ); 8753 std::swap( m_framebuffer, rhs.m_framebuffer ); 8754 std::swap( m_allocator, rhs.m_allocator ); 8755 std::swap( m_dispatcher, rhs.m_dispatcher ); 8756 } 8757 8758 //=== VK_QCOM_tile_properties === 8759 8760 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> getTilePropertiesQCOM() const; 8761 8762 private: 8763 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8764 VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer = {}; 8765 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 8766 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8767 }; 8768 8769 class Image 8770 { 8771 public: 8772 using CType = VkImage; 8773 using CppType = VULKAN_HPP_NAMESPACE::Image; 8774 8775 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage; 8776 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8777 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage; 8778 8779 public: 8780 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)8781 Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8782 VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo, 8783 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8784 { 8785 *this = device.createImage( createInfo, allocator ); 8786 } 8787 # endif 8788 Image(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkImage image,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8789 Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8790 VkImage image, 8791 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8792 : m_device( device ) 8793 , m_image( image ) 8794 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8795 , m_dispatcher( device.getDispatcher() ) 8796 { 8797 } 8798 Image(std::nullptr_t)8799 Image( std::nullptr_t ) {} 8800 ~Image()8801 ~Image() 8802 { 8803 clear(); 8804 } 8805 8806 Image() = delete; 8807 Image( Image const & ) = delete; 8808 Image(Image && rhs)8809 Image( Image && rhs ) VULKAN_HPP_NOEXCEPT 8810 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 8811 , m_image( VULKAN_HPP_NAMESPACE::exchange( rhs.m_image, {} ) ) 8812 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8813 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8814 { 8815 } 8816 8817 Image & operator=( Image const & ) = delete; 8818 operator =(Image && rhs)8819 Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT 8820 { 8821 if ( this != &rhs ) 8822 { 8823 std::swap( m_device, rhs.m_device ); 8824 std::swap( m_image, rhs.m_image ); 8825 std::swap( m_allocator, rhs.m_allocator ); 8826 std::swap( m_dispatcher, rhs.m_dispatcher ); 8827 } 8828 return *this; 8829 } 8830 operator *() const8831 VULKAN_HPP_NAMESPACE::Image const & operator*() const VULKAN_HPP_NOEXCEPT 8832 { 8833 return m_image; 8834 } 8835 operator VULKAN_HPP_NAMESPACE::Image() const8836 operator VULKAN_HPP_NAMESPACE::Image() const VULKAN_HPP_NOEXCEPT 8837 { 8838 return m_image; 8839 } 8840 clear()8841 void clear() VULKAN_HPP_NOEXCEPT 8842 { 8843 if ( m_image ) 8844 { 8845 getDispatcher()->vkDestroyImage( 8846 static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 8847 } 8848 m_device = nullptr; 8849 m_image = nullptr; 8850 m_allocator = nullptr; 8851 m_dispatcher = nullptr; 8852 } 8853 release()8854 VULKAN_HPP_NAMESPACE::Image release() 8855 { 8856 m_device = nullptr; 8857 m_allocator = nullptr; 8858 m_dispatcher = nullptr; 8859 return VULKAN_HPP_NAMESPACE::exchange( m_image, nullptr ); 8860 } 8861 getDevice() const8862 VULKAN_HPP_NAMESPACE::Device getDevice() const 8863 { 8864 return m_device; 8865 } 8866 getDispatcher() const8867 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 8868 { 8869 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 8870 return m_dispatcher; 8871 } 8872 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image & rhs)8873 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image & rhs ) VULKAN_HPP_NOEXCEPT 8874 { 8875 std::swap( m_device, rhs.m_device ); 8876 std::swap( m_image, rhs.m_image ); 8877 std::swap( m_allocator, rhs.m_allocator ); 8878 std::swap( m_dispatcher, rhs.m_dispatcher ); 8879 } 8880 8881 //=== VK_VERSION_1_0 === 8882 8883 void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const; 8884 8885 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; 8886 8887 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> getSparseMemoryRequirements() const; 8888 8889 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout 8890 getSubresourceLayout( const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT; 8891 8892 //=== VK_VERSION_1_4 === 8893 8894 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 8895 getSubresourceLayout2( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; 8896 8897 template <typename X, typename Y, typename... Z> 8898 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 8899 getSubresourceLayout2( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; 8900 8901 //=== VK_EXT_image_drm_format_modifier === 8902 8903 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT getDrmFormatModifierPropertiesEXT() const; 8904 8905 //=== VK_EXT_host_image_copy === 8906 8907 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 8908 getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; 8909 8910 template <typename X, typename Y, typename... Z> 8911 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 8912 getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; 8913 8914 //=== VK_KHR_maintenance5 === 8915 8916 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2 8917 getSubresourceLayout2KHR( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; 8918 8919 template <typename X, typename Y, typename... Z> 8920 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> 8921 getSubresourceLayout2KHR( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; 8922 8923 private: 8924 VULKAN_HPP_NAMESPACE::Device m_device = {}; 8925 VULKAN_HPP_NAMESPACE::Image m_image = {}; 8926 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 8927 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 8928 }; 8929 8930 class ImageView 8931 { 8932 public: 8933 using CType = VkImageView; 8934 using CppType = VULKAN_HPP_NAMESPACE::ImageView; 8935 8936 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView; 8937 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 8938 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView; 8939 8940 public: 8941 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)8942 ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8943 VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo, 8944 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8945 { 8946 *this = device.createImageView( createInfo, allocator ); 8947 } 8948 # endif 8949 ImageView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkImageView imageView,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)8950 ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 8951 VkImageView imageView, 8952 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 8953 : m_device( device ) 8954 , m_imageView( imageView ) 8955 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 8956 , m_dispatcher( device.getDispatcher() ) 8957 { 8958 } 8959 ImageView(std::nullptr_t)8960 ImageView( std::nullptr_t ) {} 8961 ~ImageView()8962 ~ImageView() 8963 { 8964 clear(); 8965 } 8966 8967 ImageView() = delete; 8968 ImageView( ImageView const & ) = delete; 8969 ImageView(ImageView && rhs)8970 ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT 8971 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 8972 , m_imageView( VULKAN_HPP_NAMESPACE::exchange( rhs.m_imageView, {} ) ) 8973 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 8974 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 8975 { 8976 } 8977 8978 ImageView & operator=( ImageView const & ) = delete; 8979 operator =(ImageView && rhs)8980 ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT 8981 { 8982 if ( this != &rhs ) 8983 { 8984 std::swap( m_device, rhs.m_device ); 8985 std::swap( m_imageView, rhs.m_imageView ); 8986 std::swap( m_allocator, rhs.m_allocator ); 8987 std::swap( m_dispatcher, rhs.m_dispatcher ); 8988 } 8989 return *this; 8990 } 8991 operator *() const8992 VULKAN_HPP_NAMESPACE::ImageView const & operator*() const VULKAN_HPP_NOEXCEPT 8993 { 8994 return m_imageView; 8995 } 8996 operator VULKAN_HPP_NAMESPACE::ImageView() const8997 operator VULKAN_HPP_NAMESPACE::ImageView() const VULKAN_HPP_NOEXCEPT 8998 { 8999 return m_imageView; 9000 } 9001 clear()9002 void clear() VULKAN_HPP_NOEXCEPT 9003 { 9004 if ( m_imageView ) 9005 { 9006 getDispatcher()->vkDestroyImageView( 9007 static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9008 } 9009 m_device = nullptr; 9010 m_imageView = nullptr; 9011 m_allocator = nullptr; 9012 m_dispatcher = nullptr; 9013 } 9014 release()9015 VULKAN_HPP_NAMESPACE::ImageView release() 9016 { 9017 m_device = nullptr; 9018 m_allocator = nullptr; 9019 m_dispatcher = nullptr; 9020 return VULKAN_HPP_NAMESPACE::exchange( m_imageView, nullptr ); 9021 } 9022 getDevice() const9023 VULKAN_HPP_NAMESPACE::Device getDevice() const 9024 { 9025 return m_device; 9026 } 9027 getDispatcher() const9028 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9029 { 9030 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9031 return m_dispatcher; 9032 } 9033 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView & rhs)9034 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView & rhs ) VULKAN_HPP_NOEXCEPT 9035 { 9036 std::swap( m_device, rhs.m_device ); 9037 std::swap( m_imageView, rhs.m_imageView ); 9038 std::swap( m_allocator, rhs.m_allocator ); 9039 std::swap( m_dispatcher, rhs.m_dispatcher ); 9040 } 9041 9042 //=== VK_NVX_image_view_handle === 9043 9044 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const; 9045 9046 private: 9047 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9048 VULKAN_HPP_NAMESPACE::ImageView m_imageView = {}; 9049 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 9050 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9051 }; 9052 9053 class IndirectCommandsLayoutNV 9054 { 9055 public: 9056 using CType = VkIndirectCommandsLayoutNV; 9057 using CppType = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV; 9058 9059 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV; 9060 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9061 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 9062 9063 public: 9064 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9065 IndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9066 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo, 9067 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9068 { 9069 *this = device.createIndirectCommandsLayoutNV( createInfo, allocator ); 9070 } 9071 # endif 9072 IndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkIndirectCommandsLayoutNV indirectCommandsLayout,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9073 IndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9074 VkIndirectCommandsLayoutNV indirectCommandsLayout, 9075 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9076 : m_device( device ) 9077 , m_indirectCommandsLayout( indirectCommandsLayout ) 9078 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9079 , m_dispatcher( device.getDispatcher() ) 9080 { 9081 } 9082 IndirectCommandsLayoutNV(std::nullptr_t)9083 IndirectCommandsLayoutNV( std::nullptr_t ) {} 9084 ~IndirectCommandsLayoutNV()9085 ~IndirectCommandsLayoutNV() 9086 { 9087 clear(); 9088 } 9089 9090 IndirectCommandsLayoutNV() = delete; 9091 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & ) = delete; 9092 IndirectCommandsLayoutNV(IndirectCommandsLayoutNV && rhs)9093 IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT 9094 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 9095 , m_indirectCommandsLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ) ) 9096 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9097 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9098 { 9099 } 9100 9101 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & ) = delete; 9102 operator =(IndirectCommandsLayoutNV && rhs)9103 IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT 9104 { 9105 if ( this != &rhs ) 9106 { 9107 std::swap( m_device, rhs.m_device ); 9108 std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout ); 9109 std::swap( m_allocator, rhs.m_allocator ); 9110 std::swap( m_dispatcher, rhs.m_dispatcher ); 9111 } 9112 return *this; 9113 } 9114 operator *() const9115 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const VULKAN_HPP_NOEXCEPT 9116 { 9117 return m_indirectCommandsLayout; 9118 } 9119 operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV() const9120 operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT 9121 { 9122 return m_indirectCommandsLayout; 9123 } 9124 clear()9125 void clear() VULKAN_HPP_NOEXCEPT 9126 { 9127 if ( m_indirectCommandsLayout ) 9128 { 9129 getDispatcher()->vkDestroyIndirectCommandsLayoutNV( static_cast<VkDevice>( m_device ), 9130 static_cast<VkIndirectCommandsLayoutNV>( m_indirectCommandsLayout ), 9131 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9132 } 9133 m_device = nullptr; 9134 m_indirectCommandsLayout = nullptr; 9135 m_allocator = nullptr; 9136 m_dispatcher = nullptr; 9137 } 9138 release()9139 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV release() 9140 { 9141 m_device = nullptr; 9142 m_allocator = nullptr; 9143 m_dispatcher = nullptr; 9144 return VULKAN_HPP_NAMESPACE::exchange( m_indirectCommandsLayout, nullptr ); 9145 } 9146 getDevice() const9147 VULKAN_HPP_NAMESPACE::Device getDevice() const 9148 { 9149 return m_device; 9150 } 9151 getDispatcher() const9152 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9153 { 9154 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9155 return m_dispatcher; 9156 } 9157 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV & rhs)9158 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV & rhs ) VULKAN_HPP_NOEXCEPT 9159 { 9160 std::swap( m_device, rhs.m_device ); 9161 std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout ); 9162 std::swap( m_allocator, rhs.m_allocator ); 9163 std::swap( m_dispatcher, rhs.m_dispatcher ); 9164 } 9165 9166 private: 9167 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9168 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayout = {}; 9169 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 9170 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9171 }; 9172 9173 class MicromapEXT 9174 { 9175 public: 9176 using CType = VkMicromapEXT; 9177 using CppType = VULKAN_HPP_NAMESPACE::MicromapEXT; 9178 9179 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT; 9180 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9181 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 9182 9183 public: 9184 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) MicromapEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9185 MicromapEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9186 VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo, 9187 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9188 { 9189 *this = device.createMicromapEXT( createInfo, allocator ); 9190 } 9191 # endif 9192 MicromapEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkMicromapEXT micromap,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9193 MicromapEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9194 VkMicromapEXT micromap, 9195 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9196 : m_device( device ) 9197 , m_micromap( micromap ) 9198 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9199 , m_dispatcher( device.getDispatcher() ) 9200 { 9201 } 9202 MicromapEXT(std::nullptr_t)9203 MicromapEXT( std::nullptr_t ) {} 9204 ~MicromapEXT()9205 ~MicromapEXT() 9206 { 9207 clear(); 9208 } 9209 9210 MicromapEXT() = delete; 9211 MicromapEXT( MicromapEXT const & ) = delete; 9212 MicromapEXT(MicromapEXT && rhs)9213 MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT 9214 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 9215 , m_micromap( VULKAN_HPP_NAMESPACE::exchange( rhs.m_micromap, {} ) ) 9216 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9217 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9218 { 9219 } 9220 9221 MicromapEXT & operator=( MicromapEXT const & ) = delete; 9222 operator =(MicromapEXT && rhs)9223 MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT 9224 { 9225 if ( this != &rhs ) 9226 { 9227 std::swap( m_device, rhs.m_device ); 9228 std::swap( m_micromap, rhs.m_micromap ); 9229 std::swap( m_allocator, rhs.m_allocator ); 9230 std::swap( m_dispatcher, rhs.m_dispatcher ); 9231 } 9232 return *this; 9233 } 9234 operator *() const9235 VULKAN_HPP_NAMESPACE::MicromapEXT const & operator*() const VULKAN_HPP_NOEXCEPT 9236 { 9237 return m_micromap; 9238 } 9239 operator VULKAN_HPP_NAMESPACE::MicromapEXT() const9240 operator VULKAN_HPP_NAMESPACE::MicromapEXT() const VULKAN_HPP_NOEXCEPT 9241 { 9242 return m_micromap; 9243 } 9244 clear()9245 void clear() VULKAN_HPP_NOEXCEPT 9246 { 9247 if ( m_micromap ) 9248 { 9249 getDispatcher()->vkDestroyMicromapEXT( 9250 static_cast<VkDevice>( m_device ), static_cast<VkMicromapEXT>( m_micromap ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9251 } 9252 m_device = nullptr; 9253 m_micromap = nullptr; 9254 m_allocator = nullptr; 9255 m_dispatcher = nullptr; 9256 } 9257 release()9258 VULKAN_HPP_NAMESPACE::MicromapEXT release() 9259 { 9260 m_device = nullptr; 9261 m_allocator = nullptr; 9262 m_dispatcher = nullptr; 9263 return VULKAN_HPP_NAMESPACE::exchange( m_micromap, nullptr ); 9264 } 9265 getDevice() const9266 VULKAN_HPP_NAMESPACE::Device getDevice() const 9267 { 9268 return m_device; 9269 } 9270 getDispatcher() const9271 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9272 { 9273 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9274 return m_dispatcher; 9275 } 9276 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT & rhs)9277 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT & rhs ) VULKAN_HPP_NOEXCEPT 9278 { 9279 std::swap( m_device, rhs.m_device ); 9280 std::swap( m_micromap, rhs.m_micromap ); 9281 std::swap( m_allocator, rhs.m_allocator ); 9282 std::swap( m_dispatcher, rhs.m_dispatcher ); 9283 } 9284 9285 private: 9286 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9287 VULKAN_HPP_NAMESPACE::MicromapEXT m_micromap = {}; 9288 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 9289 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9290 }; 9291 9292 class OpticalFlowSessionNV 9293 { 9294 public: 9295 using CType = VkOpticalFlowSessionNV; 9296 using CppType = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV; 9297 9298 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV; 9299 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9300 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 9301 9302 public: 9303 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) OpticalFlowSessionNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9304 OpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9305 VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo, 9306 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9307 { 9308 *this = device.createOpticalFlowSessionNV( createInfo, allocator ); 9309 } 9310 # endif 9311 OpticalFlowSessionNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkOpticalFlowSessionNV session,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9312 OpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9313 VkOpticalFlowSessionNV session, 9314 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9315 : m_device( device ) 9316 , m_session( session ) 9317 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9318 , m_dispatcher( device.getDispatcher() ) 9319 { 9320 } 9321 OpticalFlowSessionNV(std::nullptr_t)9322 OpticalFlowSessionNV( std::nullptr_t ) {} 9323 ~OpticalFlowSessionNV()9324 ~OpticalFlowSessionNV() 9325 { 9326 clear(); 9327 } 9328 9329 OpticalFlowSessionNV() = delete; 9330 OpticalFlowSessionNV( OpticalFlowSessionNV const & ) = delete; 9331 OpticalFlowSessionNV(OpticalFlowSessionNV && rhs)9332 OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT 9333 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 9334 , m_session( VULKAN_HPP_NAMESPACE::exchange( rhs.m_session, {} ) ) 9335 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9336 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9337 { 9338 } 9339 9340 OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & ) = delete; 9341 operator =(OpticalFlowSessionNV && rhs)9342 OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT 9343 { 9344 if ( this != &rhs ) 9345 { 9346 std::swap( m_device, rhs.m_device ); 9347 std::swap( m_session, rhs.m_session ); 9348 std::swap( m_allocator, rhs.m_allocator ); 9349 std::swap( m_dispatcher, rhs.m_dispatcher ); 9350 } 9351 return *this; 9352 } 9353 operator *() const9354 VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & operator*() const VULKAN_HPP_NOEXCEPT 9355 { 9356 return m_session; 9357 } 9358 operator VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV() const9359 operator VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT 9360 { 9361 return m_session; 9362 } 9363 clear()9364 void clear() VULKAN_HPP_NOEXCEPT 9365 { 9366 if ( m_session ) 9367 { 9368 getDispatcher()->vkDestroyOpticalFlowSessionNV( static_cast<VkDevice>( m_device ), 9369 static_cast<VkOpticalFlowSessionNV>( m_session ), 9370 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9371 } 9372 m_device = nullptr; 9373 m_session = nullptr; 9374 m_allocator = nullptr; 9375 m_dispatcher = nullptr; 9376 } 9377 release()9378 VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV release() 9379 { 9380 m_device = nullptr; 9381 m_allocator = nullptr; 9382 m_dispatcher = nullptr; 9383 return VULKAN_HPP_NAMESPACE::exchange( m_session, nullptr ); 9384 } 9385 getDevice() const9386 VULKAN_HPP_NAMESPACE::Device getDevice() const 9387 { 9388 return m_device; 9389 } 9390 getDispatcher() const9391 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9392 { 9393 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9394 return m_dispatcher; 9395 } 9396 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV & rhs)9397 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV & rhs ) VULKAN_HPP_NOEXCEPT 9398 { 9399 std::swap( m_device, rhs.m_device ); 9400 std::swap( m_session, rhs.m_session ); 9401 std::swap( m_allocator, rhs.m_allocator ); 9402 std::swap( m_dispatcher, rhs.m_dispatcher ); 9403 } 9404 9405 //=== VK_NV_optical_flow === 9406 9407 void bindImage( VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, 9408 VULKAN_HPP_NAMESPACE::ImageView view, 9409 VULKAN_HPP_NAMESPACE::ImageLayout layout ) const; 9410 9411 private: 9412 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9413 VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV m_session = {}; 9414 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 9415 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9416 }; 9417 9418 class PerformanceConfigurationINTEL 9419 { 9420 public: 9421 using CType = VkPerformanceConfigurationINTEL; 9422 using CppType = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL; 9423 9424 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL; 9425 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9426 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 9427 9428 public: 9429 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) PerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo)9430 PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9431 VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) 9432 { 9433 *this = device.acquirePerformanceConfigurationINTEL( acquireInfo ); 9434 } 9435 # endif 9436 PerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPerformanceConfigurationINTEL configuration)9437 PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkPerformanceConfigurationINTEL configuration ) 9438 : m_device( device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() ) 9439 { 9440 } 9441 PerformanceConfigurationINTEL(std::nullptr_t)9442 PerformanceConfigurationINTEL( std::nullptr_t ) {} 9443 ~PerformanceConfigurationINTEL()9444 ~PerformanceConfigurationINTEL() 9445 { 9446 clear(); 9447 } 9448 9449 PerformanceConfigurationINTEL() = delete; 9450 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & ) = delete; 9451 PerformanceConfigurationINTEL(PerformanceConfigurationINTEL && rhs)9452 PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT 9453 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 9454 , m_configuration( VULKAN_HPP_NAMESPACE::exchange( rhs.m_configuration, {} ) ) 9455 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9456 { 9457 } 9458 9459 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & ) = delete; 9460 operator =(PerformanceConfigurationINTEL && rhs)9461 PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT 9462 { 9463 if ( this != &rhs ) 9464 { 9465 std::swap( m_device, rhs.m_device ); 9466 std::swap( m_configuration, rhs.m_configuration ); 9467 std::swap( m_dispatcher, rhs.m_dispatcher ); 9468 } 9469 return *this; 9470 } 9471 operator *() const9472 VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const VULKAN_HPP_NOEXCEPT 9473 { 9474 return m_configuration; 9475 } 9476 operator VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL() const9477 operator VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT 9478 { 9479 return m_configuration; 9480 } 9481 clear()9482 void clear() VULKAN_HPP_NOEXCEPT 9483 { 9484 if ( m_configuration ) 9485 { 9486 getDispatcher()->vkReleasePerformanceConfigurationINTEL( static_cast<VkDevice>( m_device ), 9487 static_cast<VkPerformanceConfigurationINTEL>( m_configuration ) ); 9488 } 9489 m_device = nullptr; 9490 m_configuration = nullptr; 9491 m_dispatcher = nullptr; 9492 } 9493 release()9494 VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL release() 9495 { 9496 m_device = nullptr; 9497 m_dispatcher = nullptr; 9498 return VULKAN_HPP_NAMESPACE::exchange( m_configuration, nullptr ); 9499 } 9500 getDevice() const9501 VULKAN_HPP_NAMESPACE::Device getDevice() const 9502 { 9503 return m_device; 9504 } 9505 getDispatcher() const9506 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9507 { 9508 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9509 return m_dispatcher; 9510 } 9511 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL & rhs)9512 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL & rhs ) VULKAN_HPP_NOEXCEPT 9513 { 9514 std::swap( m_device, rhs.m_device ); 9515 std::swap( m_configuration, rhs.m_configuration ); 9516 std::swap( m_dispatcher, rhs.m_dispatcher ); 9517 } 9518 9519 private: 9520 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9521 VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_configuration = {}; 9522 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9523 }; 9524 9525 class PipelineCache 9526 { 9527 public: 9528 using CType = VkPipelineCache; 9529 using CppType = VULKAN_HPP_NAMESPACE::PipelineCache; 9530 9531 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache; 9532 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9533 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache; 9534 9535 public: 9536 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9537 PipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9538 VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo, 9539 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9540 { 9541 *this = device.createPipelineCache( createInfo, allocator ); 9542 } 9543 # endif 9544 PipelineCache(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPipelineCache pipelineCache,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9545 PipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9546 VkPipelineCache pipelineCache, 9547 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9548 : m_device( device ) 9549 , m_pipelineCache( pipelineCache ) 9550 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9551 , m_dispatcher( device.getDispatcher() ) 9552 { 9553 } 9554 PipelineCache(std::nullptr_t)9555 PipelineCache( std::nullptr_t ) {} 9556 ~PipelineCache()9557 ~PipelineCache() 9558 { 9559 clear(); 9560 } 9561 9562 PipelineCache() = delete; 9563 PipelineCache( PipelineCache const & ) = delete; 9564 PipelineCache(PipelineCache && rhs)9565 PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT 9566 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 9567 , m_pipelineCache( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) ) 9568 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9569 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9570 { 9571 } 9572 9573 PipelineCache & operator=( PipelineCache const & ) = delete; 9574 operator =(PipelineCache && rhs)9575 PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT 9576 { 9577 if ( this != &rhs ) 9578 { 9579 std::swap( m_device, rhs.m_device ); 9580 std::swap( m_pipelineCache, rhs.m_pipelineCache ); 9581 std::swap( m_allocator, rhs.m_allocator ); 9582 std::swap( m_dispatcher, rhs.m_dispatcher ); 9583 } 9584 return *this; 9585 } 9586 operator *() const9587 VULKAN_HPP_NAMESPACE::PipelineCache const & operator*() const VULKAN_HPP_NOEXCEPT 9588 { 9589 return m_pipelineCache; 9590 } 9591 operator VULKAN_HPP_NAMESPACE::PipelineCache() const9592 operator VULKAN_HPP_NAMESPACE::PipelineCache() const VULKAN_HPP_NOEXCEPT 9593 { 9594 return m_pipelineCache; 9595 } 9596 clear()9597 void clear() VULKAN_HPP_NOEXCEPT 9598 { 9599 if ( m_pipelineCache ) 9600 { 9601 getDispatcher()->vkDestroyPipelineCache( static_cast<VkDevice>( m_device ), 9602 static_cast<VkPipelineCache>( m_pipelineCache ), 9603 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9604 } 9605 m_device = nullptr; 9606 m_pipelineCache = nullptr; 9607 m_allocator = nullptr; 9608 m_dispatcher = nullptr; 9609 } 9610 release()9611 VULKAN_HPP_NAMESPACE::PipelineCache release() 9612 { 9613 m_device = nullptr; 9614 m_allocator = nullptr; 9615 m_dispatcher = nullptr; 9616 return VULKAN_HPP_NAMESPACE::exchange( m_pipelineCache, nullptr ); 9617 } 9618 getDevice() const9619 VULKAN_HPP_NAMESPACE::Device getDevice() const 9620 { 9621 return m_device; 9622 } 9623 getDispatcher() const9624 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9625 { 9626 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9627 return m_dispatcher; 9628 } 9629 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache & rhs)9630 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache & rhs ) VULKAN_HPP_NOEXCEPT 9631 { 9632 std::swap( m_device, rhs.m_device ); 9633 std::swap( m_pipelineCache, rhs.m_pipelineCache ); 9634 std::swap( m_allocator, rhs.m_allocator ); 9635 std::swap( m_dispatcher, rhs.m_dispatcher ); 9636 } 9637 9638 //=== VK_VERSION_1_0 === 9639 9640 VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const; 9641 9642 void merge( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const; 9643 9644 private: 9645 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9646 VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache = {}; 9647 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 9648 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9649 }; 9650 9651 class Pipeline 9652 { 9653 public: 9654 using CType = VkPipeline; 9655 using CppType = VULKAN_HPP_NAMESPACE::Pipeline; 9656 9657 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline; 9658 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9659 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline; 9660 9661 public: 9662 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9663 Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9664 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9665 VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo, 9666 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9667 { 9668 *this = device.createComputePipeline( pipelineCache, createInfo, allocator ); 9669 } 9670 # endif 9671 9672 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 9673 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 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::ExecutionGraphPipelineCreateInfoAMDX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9674 Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9675 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9676 VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & createInfo, 9677 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9678 { 9679 *this = device.createExecutionGraphPipelineAMDX( pipelineCache, createInfo, allocator ); 9680 } 9681 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 9682 # endif 9683 9684 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9685 Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9686 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9687 VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo, 9688 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9689 { 9690 *this = device.createGraphicsPipeline( pipelineCache, createInfo, allocator ); 9691 } 9692 # endif 9693 9694 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9695 Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9696 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 9697 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9698 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo, 9699 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9700 { 9701 *this = device.createRayTracingPipelineKHR( deferredOperation, pipelineCache, createInfo, allocator ); 9702 } 9703 # endif 9704 9705 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9706 Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9707 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9708 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo, 9709 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9710 { 9711 *this = device.createRayTracingPipelineNV( pipelineCache, createInfo, allocator ); 9712 } 9713 # endif 9714 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)9715 Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9716 VkPipeline pipeline, 9717 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr, 9718 VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9719 : m_device( device ) 9720 , m_pipeline( pipeline ) 9721 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9722 , m_constructorSuccessCode( successCode ) 9723 , m_dispatcher( device.getDispatcher() ) 9724 { 9725 } 9726 Pipeline(std::nullptr_t)9727 Pipeline( std::nullptr_t ) {} 9728 ~Pipeline()9729 ~Pipeline() 9730 { 9731 clear(); 9732 } 9733 9734 Pipeline() = delete; 9735 Pipeline( Pipeline const & ) = delete; 9736 Pipeline(Pipeline && rhs)9737 Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT 9738 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 9739 , m_pipeline( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipeline, {} ) ) 9740 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9741 , m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) ) 9742 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9743 { 9744 } 9745 9746 Pipeline & operator=( Pipeline const & ) = delete; 9747 operator =(Pipeline && rhs)9748 Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT 9749 { 9750 if ( this != &rhs ) 9751 { 9752 std::swap( m_device, rhs.m_device ); 9753 std::swap( m_pipeline, rhs.m_pipeline ); 9754 std::swap( m_allocator, rhs.m_allocator ); 9755 std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); 9756 std::swap( m_dispatcher, rhs.m_dispatcher ); 9757 } 9758 return *this; 9759 } 9760 operator *() const9761 VULKAN_HPP_NAMESPACE::Pipeline const & operator*() const VULKAN_HPP_NOEXCEPT 9762 { 9763 return m_pipeline; 9764 } 9765 operator VULKAN_HPP_NAMESPACE::Pipeline() const9766 operator VULKAN_HPP_NAMESPACE::Pipeline() const VULKAN_HPP_NOEXCEPT 9767 { 9768 return m_pipeline; 9769 } 9770 clear()9771 void clear() VULKAN_HPP_NOEXCEPT 9772 { 9773 if ( m_pipeline ) 9774 { 9775 getDispatcher()->vkDestroyPipeline( 9776 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 9777 } 9778 m_device = nullptr; 9779 m_pipeline = nullptr; 9780 m_allocator = nullptr; 9781 m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; 9782 m_dispatcher = nullptr; 9783 } 9784 release()9785 VULKAN_HPP_NAMESPACE::Pipeline release() 9786 { 9787 m_device = nullptr; 9788 m_allocator = nullptr; 9789 m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; 9790 m_dispatcher = nullptr; 9791 return VULKAN_HPP_NAMESPACE::exchange( m_pipeline, nullptr ); 9792 } 9793 getConstructorSuccessCode() const9794 VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const 9795 { 9796 return m_constructorSuccessCode; 9797 } 9798 getDevice() const9799 VULKAN_HPP_NAMESPACE::Device getDevice() const 9800 { 9801 return m_device; 9802 } 9803 getDispatcher() const9804 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 9805 { 9806 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 9807 return m_dispatcher; 9808 } 9809 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline & rhs)9810 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline & rhs ) VULKAN_HPP_NOEXCEPT 9811 { 9812 std::swap( m_device, rhs.m_device ); 9813 std::swap( m_pipeline, rhs.m_pipeline ); 9814 std::swap( m_allocator, rhs.m_allocator ); 9815 std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); 9816 std::swap( m_dispatcher, rhs.m_dispatcher ); 9817 } 9818 9819 //=== VK_AMD_shader_info === 9820 9821 VULKAN_HPP_NODISCARD std::vector<uint8_t> getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, 9822 VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType ) const; 9823 9824 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 9825 //=== VK_AMDX_shader_enqueue === 9826 9827 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX getExecutionGraphScratchSizeAMDX() const; 9828 9829 VULKAN_HPP_NODISCARD uint32_t getExecutionGraphNodeIndexAMDX( const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo ) const; 9830 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 9831 9832 //=== VK_KHR_ray_tracing_pipeline === 9833 9834 template <typename DataType> 9835 VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; 9836 9837 template <typename DataType> 9838 VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const; 9839 9840 template <typename DataType> 9841 VULKAN_HPP_NODISCARD std::vector<DataType> 9842 getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; 9843 9844 template <typename DataType> 9845 VULKAN_HPP_NODISCARD DataType getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const; 9846 9847 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize 9848 getRayTracingShaderGroupStackSizeKHR( uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT; 9849 9850 //=== VK_NV_ray_tracing === 9851 9852 template <typename DataType> 9853 VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; 9854 9855 template <typename DataType> 9856 VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const; 9857 9858 void compileDeferredNV( uint32_t shader ) const; 9859 9860 private: 9861 VULKAN_HPP_NAMESPACE::Device m_device = {}; 9862 VULKAN_HPP_NAMESPACE::Pipeline m_pipeline = {}; 9863 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 9864 VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; 9865 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 9866 }; 9867 9868 class Pipelines : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> 9869 { 9870 public: 9871 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9872 Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9873 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9874 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, 9875 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9876 { 9877 *this = device.createComputePipelines( pipelineCache, createInfos, allocator ); 9878 } 9879 # endif 9880 9881 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 9882 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 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::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)9883 Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9884 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9885 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, 9886 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9887 { 9888 *this = device.createExecutionGraphPipelinesAMDX( pipelineCache, createInfos, allocator ); 9889 } 9890 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 9891 # endif 9892 9893 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9894 Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9895 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9896 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, 9897 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9898 { 9899 *this = device.createGraphicsPipelines( pipelineCache, createInfos, allocator ); 9900 } 9901 # endif 9902 9903 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9904 Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9905 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 9906 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9907 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, 9908 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9909 { 9910 *this = device.createRayTracingPipelinesKHR( deferredOperation, pipelineCache, createInfos, allocator ); 9911 } 9912 # endif 9913 9914 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)9915 Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9916 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 9917 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, 9918 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 9919 { 9920 *this = device.createRayTracingPipelinesNV( pipelineCache, createInfos, allocator ); 9921 } 9922 # endif 9923 Pipelines(std::nullptr_t)9924 Pipelines( std::nullptr_t ) {} 9925 9926 Pipelines() = delete; 9927 Pipelines( Pipelines const & ) = delete; 9928 Pipelines( Pipelines && rhs ) = default; 9929 Pipelines & operator=( Pipelines const & ) = delete; 9930 Pipelines & operator=( Pipelines && rhs ) = default; 9931 9932 private: Pipelines(std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> && rhs)9933 Pipelines( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> && rhs ) 9934 { 9935 std::swap( *this, rhs ); 9936 } 9937 }; 9938 9939 class PipelineBinaryKHR 9940 { 9941 public: 9942 using CType = VkPipelineBinaryKHR; 9943 using CppType = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR; 9944 9945 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR; 9946 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 9947 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 9948 9949 public: PipelineBinaryKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPipelineBinaryKHR pipelineBinary,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr,VULKAN_HPP_NAMESPACE::Result successCode=VULKAN_HPP_NAMESPACE::Result::eSuccess)9950 PipelineBinaryKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 9951 VkPipelineBinaryKHR pipelineBinary, 9952 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr, 9953 VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess ) 9954 : m_device( device ) 9955 , m_pipelineBinary( pipelineBinary ) 9956 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 9957 , m_constructorSuccessCode( successCode ) 9958 , m_dispatcher( device.getDispatcher() ) 9959 { 9960 } 9961 PipelineBinaryKHR(std::nullptr_t)9962 PipelineBinaryKHR( std::nullptr_t ) {} 9963 ~PipelineBinaryKHR()9964 ~PipelineBinaryKHR() 9965 { 9966 clear(); 9967 } 9968 9969 PipelineBinaryKHR() = delete; 9970 PipelineBinaryKHR( PipelineBinaryKHR const & ) = delete; 9971 PipelineBinaryKHR(PipelineBinaryKHR && rhs)9972 PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT 9973 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 9974 , m_pipelineBinary( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinary, {} ) ) 9975 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 9976 , m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) ) 9977 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 9978 { 9979 } 9980 9981 PipelineBinaryKHR & operator=( PipelineBinaryKHR const & ) = delete; 9982 operator =(PipelineBinaryKHR && rhs)9983 PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT 9984 { 9985 if ( this != &rhs ) 9986 { 9987 std::swap( m_device, rhs.m_device ); 9988 std::swap( m_pipelineBinary, rhs.m_pipelineBinary ); 9989 std::swap( m_allocator, rhs.m_allocator ); 9990 std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); 9991 std::swap( m_dispatcher, rhs.m_dispatcher ); 9992 } 9993 return *this; 9994 } 9995 operator *() const9996 VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & operator*() const VULKAN_HPP_NOEXCEPT 9997 { 9998 return m_pipelineBinary; 9999 } 10000 operator VULKAN_HPP_NAMESPACE::PipelineBinaryKHR() const10001 operator VULKAN_HPP_NAMESPACE::PipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT 10002 { 10003 return m_pipelineBinary; 10004 } 10005 clear()10006 void clear() VULKAN_HPP_NOEXCEPT 10007 { 10008 if ( m_pipelineBinary ) 10009 { 10010 getDispatcher()->vkDestroyPipelineBinaryKHR( static_cast<VkDevice>( m_device ), 10011 static_cast<VkPipelineBinaryKHR>( m_pipelineBinary ), 10012 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 10013 } 10014 m_device = nullptr; 10015 m_pipelineBinary = nullptr; 10016 m_allocator = nullptr; 10017 m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; 10018 m_dispatcher = nullptr; 10019 } 10020 release()10021 VULKAN_HPP_NAMESPACE::PipelineBinaryKHR release() 10022 { 10023 m_device = nullptr; 10024 m_allocator = nullptr; 10025 m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; 10026 m_dispatcher = nullptr; 10027 return VULKAN_HPP_NAMESPACE::exchange( m_pipelineBinary, nullptr ); 10028 } 10029 getConstructorSuccessCode() const10030 VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const 10031 { 10032 return m_constructorSuccessCode; 10033 } 10034 getDevice() const10035 VULKAN_HPP_NAMESPACE::Device getDevice() const 10036 { 10037 return m_device; 10038 } 10039 getDispatcher() const10040 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 10041 { 10042 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 10043 return m_dispatcher; 10044 } 10045 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR & rhs)10046 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR & rhs ) VULKAN_HPP_NOEXCEPT 10047 { 10048 std::swap( m_device, rhs.m_device ); 10049 std::swap( m_pipelineBinary, rhs.m_pipelineBinary ); 10050 std::swap( m_allocator, rhs.m_allocator ); 10051 std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); 10052 std::swap( m_dispatcher, rhs.m_dispatcher ); 10053 } 10054 10055 private: 10056 VULKAN_HPP_NAMESPACE::Device m_device = {}; 10057 VULKAN_HPP_NAMESPACE::PipelineBinaryKHR m_pipelineBinary = {}; 10058 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 10059 VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; 10060 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 10061 }; 10062 10063 class PipelineBinaryKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR> 10064 { 10065 public: 10066 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) PipelineBinaryKHRs(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)10067 PipelineBinaryKHRs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10068 VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & createInfo, 10069 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10070 { 10071 *this = device.createPipelineBinariesKHR( createInfo, allocator ); 10072 } 10073 # endif 10074 PipelineBinaryKHRs(std::nullptr_t)10075 PipelineBinaryKHRs( std::nullptr_t ) {} 10076 10077 PipelineBinaryKHRs() = delete; 10078 PipelineBinaryKHRs( PipelineBinaryKHRs const & ) = delete; 10079 PipelineBinaryKHRs( PipelineBinaryKHRs && rhs ) = default; 10080 PipelineBinaryKHRs & operator=( PipelineBinaryKHRs const & ) = delete; 10081 PipelineBinaryKHRs & operator=( PipelineBinaryKHRs && rhs ) = default; 10082 10083 private: PipelineBinaryKHRs(std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR> && rhs)10084 PipelineBinaryKHRs( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR> && rhs ) 10085 { 10086 std::swap( *this, rhs ); 10087 } 10088 }; 10089 10090 class PipelineLayout 10091 { 10092 public: 10093 using CType = VkPipelineLayout; 10094 using CppType = VULKAN_HPP_NAMESPACE::PipelineLayout; 10095 10096 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout; 10097 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 10098 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout; 10099 10100 public: 10101 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)10102 PipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10103 VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo, 10104 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10105 { 10106 *this = device.createPipelineLayout( createInfo, allocator ); 10107 } 10108 # endif 10109 PipelineLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPipelineLayout pipelineLayout,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)10110 PipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10111 VkPipelineLayout pipelineLayout, 10112 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10113 : m_device( device ) 10114 , m_pipelineLayout( pipelineLayout ) 10115 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 10116 , m_dispatcher( device.getDispatcher() ) 10117 { 10118 } 10119 PipelineLayout(std::nullptr_t)10120 PipelineLayout( std::nullptr_t ) {} 10121 ~PipelineLayout()10122 ~PipelineLayout() 10123 { 10124 clear(); 10125 } 10126 10127 PipelineLayout() = delete; 10128 PipelineLayout( PipelineLayout const & ) = delete; 10129 PipelineLayout(PipelineLayout && rhs)10130 PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT 10131 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 10132 , m_pipelineLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) ) 10133 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 10134 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 10135 { 10136 } 10137 10138 PipelineLayout & operator=( PipelineLayout const & ) = delete; 10139 operator =(PipelineLayout && rhs)10140 PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT 10141 { 10142 if ( this != &rhs ) 10143 { 10144 std::swap( m_device, rhs.m_device ); 10145 std::swap( m_pipelineLayout, rhs.m_pipelineLayout ); 10146 std::swap( m_allocator, rhs.m_allocator ); 10147 std::swap( m_dispatcher, rhs.m_dispatcher ); 10148 } 10149 return *this; 10150 } 10151 operator *() const10152 VULKAN_HPP_NAMESPACE::PipelineLayout const & operator*() const VULKAN_HPP_NOEXCEPT 10153 { 10154 return m_pipelineLayout; 10155 } 10156 operator VULKAN_HPP_NAMESPACE::PipelineLayout() const10157 operator VULKAN_HPP_NAMESPACE::PipelineLayout() const VULKAN_HPP_NOEXCEPT 10158 { 10159 return m_pipelineLayout; 10160 } 10161 clear()10162 void clear() VULKAN_HPP_NOEXCEPT 10163 { 10164 if ( m_pipelineLayout ) 10165 { 10166 getDispatcher()->vkDestroyPipelineLayout( static_cast<VkDevice>( m_device ), 10167 static_cast<VkPipelineLayout>( m_pipelineLayout ), 10168 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 10169 } 10170 m_device = nullptr; 10171 m_pipelineLayout = nullptr; 10172 m_allocator = nullptr; 10173 m_dispatcher = nullptr; 10174 } 10175 release()10176 VULKAN_HPP_NAMESPACE::PipelineLayout release() 10177 { 10178 m_device = nullptr; 10179 m_allocator = nullptr; 10180 m_dispatcher = nullptr; 10181 return VULKAN_HPP_NAMESPACE::exchange( m_pipelineLayout, nullptr ); 10182 } 10183 getDevice() const10184 VULKAN_HPP_NAMESPACE::Device getDevice() const 10185 { 10186 return m_device; 10187 } 10188 getDispatcher() const10189 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 10190 { 10191 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 10192 return m_dispatcher; 10193 } 10194 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout & rhs)10195 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout & rhs ) VULKAN_HPP_NOEXCEPT 10196 { 10197 std::swap( m_device, rhs.m_device ); 10198 std::swap( m_pipelineLayout, rhs.m_pipelineLayout ); 10199 std::swap( m_allocator, rhs.m_allocator ); 10200 std::swap( m_dispatcher, rhs.m_dispatcher ); 10201 } 10202 10203 private: 10204 VULKAN_HPP_NAMESPACE::Device m_device = {}; 10205 VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout = {}; 10206 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 10207 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 10208 }; 10209 10210 class PrivateDataSlot 10211 { 10212 public: 10213 using CType = VkPrivateDataSlot; 10214 using CppType = VULKAN_HPP_NAMESPACE::PrivateDataSlot; 10215 10216 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot; 10217 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 10218 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 10219 10220 public: 10221 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) PrivateDataSlot(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)10222 PrivateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10223 VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo, 10224 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10225 { 10226 *this = device.createPrivateDataSlot( createInfo, allocator ); 10227 } 10228 # endif 10229 PrivateDataSlot(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkPrivateDataSlot privateDataSlot,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)10230 PrivateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10231 VkPrivateDataSlot privateDataSlot, 10232 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10233 : m_device( device ) 10234 , m_privateDataSlot( privateDataSlot ) 10235 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 10236 , m_dispatcher( device.getDispatcher() ) 10237 { 10238 } 10239 PrivateDataSlot(std::nullptr_t)10240 PrivateDataSlot( std::nullptr_t ) {} 10241 ~PrivateDataSlot()10242 ~PrivateDataSlot() 10243 { 10244 clear(); 10245 } 10246 10247 PrivateDataSlot() = delete; 10248 PrivateDataSlot( PrivateDataSlot const & ) = delete; 10249 PrivateDataSlot(PrivateDataSlot && rhs)10250 PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT 10251 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 10252 , m_privateDataSlot( VULKAN_HPP_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) ) 10253 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 10254 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 10255 { 10256 } 10257 10258 PrivateDataSlot & operator=( PrivateDataSlot const & ) = delete; 10259 operator =(PrivateDataSlot && rhs)10260 PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT 10261 { 10262 if ( this != &rhs ) 10263 { 10264 std::swap( m_device, rhs.m_device ); 10265 std::swap( m_privateDataSlot, rhs.m_privateDataSlot ); 10266 std::swap( m_allocator, rhs.m_allocator ); 10267 std::swap( m_dispatcher, rhs.m_dispatcher ); 10268 } 10269 return *this; 10270 } 10271 operator *() const10272 VULKAN_HPP_NAMESPACE::PrivateDataSlot const & operator*() const VULKAN_HPP_NOEXCEPT 10273 { 10274 return m_privateDataSlot; 10275 } 10276 operator VULKAN_HPP_NAMESPACE::PrivateDataSlot() const10277 operator VULKAN_HPP_NAMESPACE::PrivateDataSlot() const VULKAN_HPP_NOEXCEPT 10278 { 10279 return m_privateDataSlot; 10280 } 10281 clear()10282 void clear() VULKAN_HPP_NOEXCEPT 10283 { 10284 if ( m_privateDataSlot ) 10285 { 10286 getDispatcher()->vkDestroyPrivateDataSlot( static_cast<VkDevice>( m_device ), 10287 static_cast<VkPrivateDataSlot>( m_privateDataSlot ), 10288 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 10289 } 10290 m_device = nullptr; 10291 m_privateDataSlot = nullptr; 10292 m_allocator = nullptr; 10293 m_dispatcher = nullptr; 10294 } 10295 release()10296 VULKAN_HPP_NAMESPACE::PrivateDataSlot release() 10297 { 10298 m_device = nullptr; 10299 m_allocator = nullptr; 10300 m_dispatcher = nullptr; 10301 return VULKAN_HPP_NAMESPACE::exchange( m_privateDataSlot, nullptr ); 10302 } 10303 getDevice() const10304 VULKAN_HPP_NAMESPACE::Device getDevice() const 10305 { 10306 return m_device; 10307 } 10308 getDispatcher() const10309 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 10310 { 10311 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 10312 return m_dispatcher; 10313 } 10314 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot & rhs)10315 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot & rhs ) VULKAN_HPP_NOEXCEPT 10316 { 10317 std::swap( m_device, rhs.m_device ); 10318 std::swap( m_privateDataSlot, rhs.m_privateDataSlot ); 10319 std::swap( m_allocator, rhs.m_allocator ); 10320 std::swap( m_dispatcher, rhs.m_dispatcher ); 10321 } 10322 10323 private: 10324 VULKAN_HPP_NAMESPACE::Device m_device = {}; 10325 VULKAN_HPP_NAMESPACE::PrivateDataSlot m_privateDataSlot = {}; 10326 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 10327 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 10328 }; 10329 10330 class QueryPool 10331 { 10332 public: 10333 using CType = VkQueryPool; 10334 using CppType = VULKAN_HPP_NAMESPACE::QueryPool; 10335 10336 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool; 10337 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 10338 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool; 10339 10340 public: 10341 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)10342 QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10343 VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo, 10344 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10345 { 10346 *this = device.createQueryPool( createInfo, allocator ); 10347 } 10348 # endif 10349 QueryPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkQueryPool queryPool,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)10350 QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10351 VkQueryPool queryPool, 10352 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10353 : m_device( device ) 10354 , m_queryPool( queryPool ) 10355 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 10356 , m_dispatcher( device.getDispatcher() ) 10357 { 10358 } 10359 QueryPool(std::nullptr_t)10360 QueryPool( std::nullptr_t ) {} 10361 ~QueryPool()10362 ~QueryPool() 10363 { 10364 clear(); 10365 } 10366 10367 QueryPool() = delete; 10368 QueryPool( QueryPool const & ) = delete; 10369 QueryPool(QueryPool && rhs)10370 QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT 10371 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 10372 , m_queryPool( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queryPool, {} ) ) 10373 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 10374 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 10375 { 10376 } 10377 10378 QueryPool & operator=( QueryPool const & ) = delete; 10379 operator =(QueryPool && rhs)10380 QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT 10381 { 10382 if ( this != &rhs ) 10383 { 10384 std::swap( m_device, rhs.m_device ); 10385 std::swap( m_queryPool, rhs.m_queryPool ); 10386 std::swap( m_allocator, rhs.m_allocator ); 10387 std::swap( m_dispatcher, rhs.m_dispatcher ); 10388 } 10389 return *this; 10390 } 10391 operator *() const10392 VULKAN_HPP_NAMESPACE::QueryPool const & operator*() const VULKAN_HPP_NOEXCEPT 10393 { 10394 return m_queryPool; 10395 } 10396 operator VULKAN_HPP_NAMESPACE::QueryPool() const10397 operator VULKAN_HPP_NAMESPACE::QueryPool() const VULKAN_HPP_NOEXCEPT 10398 { 10399 return m_queryPool; 10400 } 10401 clear()10402 void clear() VULKAN_HPP_NOEXCEPT 10403 { 10404 if ( m_queryPool ) 10405 { 10406 getDispatcher()->vkDestroyQueryPool( 10407 static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 10408 } 10409 m_device = nullptr; 10410 m_queryPool = nullptr; 10411 m_allocator = nullptr; 10412 m_dispatcher = nullptr; 10413 } 10414 release()10415 VULKAN_HPP_NAMESPACE::QueryPool release() 10416 { 10417 m_device = nullptr; 10418 m_allocator = nullptr; 10419 m_dispatcher = nullptr; 10420 return VULKAN_HPP_NAMESPACE::exchange( m_queryPool, nullptr ); 10421 } 10422 getDevice() const10423 VULKAN_HPP_NAMESPACE::Device getDevice() const 10424 { 10425 return m_device; 10426 } 10427 getDispatcher() const10428 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 10429 { 10430 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 10431 return m_dispatcher; 10432 } 10433 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool & rhs)10434 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool & rhs ) VULKAN_HPP_NOEXCEPT 10435 { 10436 std::swap( m_device, rhs.m_device ); 10437 std::swap( m_queryPool, rhs.m_queryPool ); 10438 std::swap( m_allocator, rhs.m_allocator ); 10439 std::swap( m_dispatcher, rhs.m_dispatcher ); 10440 } 10441 10442 //=== VK_VERSION_1_0 === 10443 10444 template <typename DataType> 10445 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>> 10446 getResults( uint32_t firstQuery, 10447 uint32_t queryCount, 10448 size_t dataSize, 10449 VULKAN_HPP_NAMESPACE::DeviceSize stride, 10450 VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 10451 10452 template <typename DataType> 10453 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, DataType> 10454 getResult( uint32_t firstQuery, 10455 uint32_t queryCount, 10456 VULKAN_HPP_NAMESPACE::DeviceSize stride, 10457 VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 10458 10459 //=== VK_VERSION_1_2 === 10460 10461 void reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; 10462 10463 //=== VK_EXT_host_query_reset === 10464 10465 void resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; 10466 10467 private: 10468 VULKAN_HPP_NAMESPACE::Device m_device = {}; 10469 VULKAN_HPP_NAMESPACE::QueryPool m_queryPool = {}; 10470 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 10471 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 10472 }; 10473 10474 class Queue 10475 { 10476 public: 10477 using CType = VkQueue; 10478 using CppType = VULKAN_HPP_NAMESPACE::Queue; 10479 10480 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue; 10481 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 10482 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue; 10483 10484 public: 10485 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,uint32_t queueFamilyIndex,uint32_t queueIndex)10486 Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, uint32_t queueFamilyIndex, uint32_t queueIndex ) 10487 { 10488 *this = device.getQueue( queueFamilyIndex, queueIndex ); 10489 } 10490 # endif 10491 10492 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo)10493 Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) 10494 { 10495 *this = device.getQueue2( queueInfo ); 10496 } 10497 # endif 10498 Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkQueue queue)10499 Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkQueue queue ) : m_queue( queue ), m_dispatcher( device.getDispatcher() ) 10500 { 10501 } 10502 Queue(std::nullptr_t)10503 Queue( std::nullptr_t ) {} 10504 ~Queue()10505 ~Queue() 10506 { 10507 clear(); 10508 } 10509 10510 Queue() = delete; 10511 Queue(Queue const & rhs)10512 Queue( Queue const & rhs ) : m_queue( rhs.m_queue ), m_dispatcher( rhs.m_dispatcher ) {} 10513 Queue(Queue && rhs)10514 Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT 10515 : m_queue( VULKAN_HPP_NAMESPACE::exchange( rhs.m_queue, {} ) ) 10516 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 10517 { 10518 } 10519 operator =(Queue const & rhs)10520 Queue & operator=( Queue const & rhs ) 10521 { 10522 m_queue = rhs.m_queue; 10523 m_dispatcher = rhs.m_dispatcher; 10524 return *this; 10525 } 10526 operator =(Queue && rhs)10527 Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT 10528 { 10529 if ( this != &rhs ) 10530 { 10531 std::swap( m_queue, rhs.m_queue ); 10532 std::swap( m_dispatcher, rhs.m_dispatcher ); 10533 } 10534 return *this; 10535 } 10536 operator *() const10537 VULKAN_HPP_NAMESPACE::Queue const & operator*() const VULKAN_HPP_NOEXCEPT 10538 { 10539 return m_queue; 10540 } 10541 operator VULKAN_HPP_NAMESPACE::Queue() const10542 operator VULKAN_HPP_NAMESPACE::Queue() const VULKAN_HPP_NOEXCEPT 10543 { 10544 return m_queue; 10545 } 10546 clear()10547 void clear() VULKAN_HPP_NOEXCEPT 10548 { 10549 m_queue = nullptr; 10550 m_dispatcher = nullptr; 10551 } 10552 release()10553 VULKAN_HPP_NAMESPACE::Queue release() 10554 { 10555 m_dispatcher = nullptr; 10556 return VULKAN_HPP_NAMESPACE::exchange( m_queue, nullptr ); 10557 } 10558 getDispatcher() const10559 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 10560 { 10561 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 10562 return m_dispatcher; 10563 } 10564 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue & rhs)10565 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue & rhs ) VULKAN_HPP_NOEXCEPT 10566 { 10567 std::swap( m_queue, rhs.m_queue ); 10568 std::swap( m_dispatcher, rhs.m_dispatcher ); 10569 } 10570 10571 //=== VK_VERSION_1_0 === 10572 10573 void submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits, 10574 VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 10575 10576 void waitIdle() const; 10577 10578 void bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo, 10579 VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 10580 10581 //=== VK_VERSION_1_3 === 10582 10583 void submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, 10584 VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 10585 10586 //=== VK_KHR_swapchain === 10587 10588 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo ) const; 10589 10590 //=== VK_EXT_debug_utils === 10591 10592 void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; 10593 10594 void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; 10595 10596 void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; 10597 10598 //=== VK_NV_device_diagnostic_checkpoints === 10599 10600 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> getCheckpointDataNV() const; 10601 10602 //=== VK_INTEL_performance_query === 10603 10604 void setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const; 10605 10606 //=== VK_KHR_synchronization2 === 10607 10608 void submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, 10609 VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 10610 10611 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> getCheckpointData2NV() const; 10612 10613 //=== VK_NV_low_latency2 === 10614 10615 void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT; 10616 10617 private: 10618 VULKAN_HPP_NAMESPACE::Queue m_queue = {}; 10619 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 10620 }; 10621 10622 class RenderPass 10623 { 10624 public: 10625 using CType = VkRenderPass; 10626 using CppType = VULKAN_HPP_NAMESPACE::RenderPass; 10627 10628 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass; 10629 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 10630 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass; 10631 10632 public: 10633 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)10634 RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10635 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo, 10636 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10637 { 10638 *this = device.createRenderPass( createInfo, allocator ); 10639 } 10640 # endif 10641 10642 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)10643 RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10644 VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 10645 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10646 { 10647 *this = device.createRenderPass2( createInfo, allocator ); 10648 } 10649 # endif 10650 RenderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkRenderPass renderPass,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)10651 RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10652 VkRenderPass renderPass, 10653 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10654 : m_device( device ) 10655 , m_renderPass( renderPass ) 10656 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 10657 , m_dispatcher( device.getDispatcher() ) 10658 { 10659 } 10660 RenderPass(std::nullptr_t)10661 RenderPass( std::nullptr_t ) {} 10662 ~RenderPass()10663 ~RenderPass() 10664 { 10665 clear(); 10666 } 10667 10668 RenderPass() = delete; 10669 RenderPass( RenderPass const & ) = delete; 10670 RenderPass(RenderPass && rhs)10671 RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT 10672 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 10673 , m_renderPass( VULKAN_HPP_NAMESPACE::exchange( rhs.m_renderPass, {} ) ) 10674 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 10675 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 10676 { 10677 } 10678 10679 RenderPass & operator=( RenderPass const & ) = delete; 10680 operator =(RenderPass && rhs)10681 RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT 10682 { 10683 if ( this != &rhs ) 10684 { 10685 std::swap( m_device, rhs.m_device ); 10686 std::swap( m_renderPass, rhs.m_renderPass ); 10687 std::swap( m_allocator, rhs.m_allocator ); 10688 std::swap( m_dispatcher, rhs.m_dispatcher ); 10689 } 10690 return *this; 10691 } 10692 operator *() const10693 VULKAN_HPP_NAMESPACE::RenderPass const & operator*() const VULKAN_HPP_NOEXCEPT 10694 { 10695 return m_renderPass; 10696 } 10697 operator VULKAN_HPP_NAMESPACE::RenderPass() const10698 operator VULKAN_HPP_NAMESPACE::RenderPass() const VULKAN_HPP_NOEXCEPT 10699 { 10700 return m_renderPass; 10701 } 10702 clear()10703 void clear() VULKAN_HPP_NOEXCEPT 10704 { 10705 if ( m_renderPass ) 10706 { 10707 getDispatcher()->vkDestroyRenderPass( 10708 static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 10709 } 10710 m_device = nullptr; 10711 m_renderPass = nullptr; 10712 m_allocator = nullptr; 10713 m_dispatcher = nullptr; 10714 } 10715 release()10716 VULKAN_HPP_NAMESPACE::RenderPass release() 10717 { 10718 m_device = nullptr; 10719 m_allocator = nullptr; 10720 m_dispatcher = nullptr; 10721 return VULKAN_HPP_NAMESPACE::exchange( m_renderPass, nullptr ); 10722 } 10723 getDevice() const10724 VULKAN_HPP_NAMESPACE::Device getDevice() const 10725 { 10726 return m_device; 10727 } 10728 getDispatcher() const10729 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 10730 { 10731 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 10732 return m_dispatcher; 10733 } 10734 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass & rhs)10735 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass & rhs ) VULKAN_HPP_NOEXCEPT 10736 { 10737 std::swap( m_device, rhs.m_device ); 10738 std::swap( m_renderPass, rhs.m_renderPass ); 10739 std::swap( m_allocator, rhs.m_allocator ); 10740 std::swap( m_dispatcher, rhs.m_dispatcher ); 10741 } 10742 10743 //=== VK_VERSION_1_0 === 10744 10745 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT; 10746 10747 //=== VK_HUAWEI_subpass_shading === 10748 10749 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getSubpassShadingMaxWorkgroupSizeHUAWEI() const; 10750 10751 private: 10752 VULKAN_HPP_NAMESPACE::Device m_device = {}; 10753 VULKAN_HPP_NAMESPACE::RenderPass m_renderPass = {}; 10754 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 10755 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 10756 }; 10757 10758 class Sampler 10759 { 10760 public: 10761 using CType = VkSampler; 10762 using CppType = VULKAN_HPP_NAMESPACE::Sampler; 10763 10764 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler; 10765 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 10766 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler; 10767 10768 public: 10769 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)10770 Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10771 VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo, 10772 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10773 { 10774 *this = device.createSampler( createInfo, allocator ); 10775 } 10776 # endif 10777 Sampler(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkSampler sampler,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)10778 Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10779 VkSampler sampler, 10780 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10781 : m_device( device ) 10782 , m_sampler( sampler ) 10783 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 10784 , m_dispatcher( device.getDispatcher() ) 10785 { 10786 } 10787 Sampler(std::nullptr_t)10788 Sampler( std::nullptr_t ) {} 10789 ~Sampler()10790 ~Sampler() 10791 { 10792 clear(); 10793 } 10794 10795 Sampler() = delete; 10796 Sampler( Sampler const & ) = delete; 10797 Sampler(Sampler && rhs)10798 Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT 10799 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 10800 , m_sampler( VULKAN_HPP_NAMESPACE::exchange( rhs.m_sampler, {} ) ) 10801 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 10802 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 10803 { 10804 } 10805 10806 Sampler & operator=( Sampler const & ) = delete; 10807 operator =(Sampler && rhs)10808 Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT 10809 { 10810 if ( this != &rhs ) 10811 { 10812 std::swap( m_device, rhs.m_device ); 10813 std::swap( m_sampler, rhs.m_sampler ); 10814 std::swap( m_allocator, rhs.m_allocator ); 10815 std::swap( m_dispatcher, rhs.m_dispatcher ); 10816 } 10817 return *this; 10818 } 10819 operator *() const10820 VULKAN_HPP_NAMESPACE::Sampler const & operator*() const VULKAN_HPP_NOEXCEPT 10821 { 10822 return m_sampler; 10823 } 10824 operator VULKAN_HPP_NAMESPACE::Sampler() const10825 operator VULKAN_HPP_NAMESPACE::Sampler() const VULKAN_HPP_NOEXCEPT 10826 { 10827 return m_sampler; 10828 } 10829 clear()10830 void clear() VULKAN_HPP_NOEXCEPT 10831 { 10832 if ( m_sampler ) 10833 { 10834 getDispatcher()->vkDestroySampler( 10835 static_cast<VkDevice>( m_device ), static_cast<VkSampler>( m_sampler ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 10836 } 10837 m_device = nullptr; 10838 m_sampler = nullptr; 10839 m_allocator = nullptr; 10840 m_dispatcher = nullptr; 10841 } 10842 release()10843 VULKAN_HPP_NAMESPACE::Sampler release() 10844 { 10845 m_device = nullptr; 10846 m_allocator = nullptr; 10847 m_dispatcher = nullptr; 10848 return VULKAN_HPP_NAMESPACE::exchange( m_sampler, nullptr ); 10849 } 10850 getDevice() const10851 VULKAN_HPP_NAMESPACE::Device getDevice() const 10852 { 10853 return m_device; 10854 } 10855 getDispatcher() const10856 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 10857 { 10858 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 10859 return m_dispatcher; 10860 } 10861 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler & rhs)10862 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler & rhs ) VULKAN_HPP_NOEXCEPT 10863 { 10864 std::swap( m_device, rhs.m_device ); 10865 std::swap( m_sampler, rhs.m_sampler ); 10866 std::swap( m_allocator, rhs.m_allocator ); 10867 std::swap( m_dispatcher, rhs.m_dispatcher ); 10868 } 10869 10870 private: 10871 VULKAN_HPP_NAMESPACE::Device m_device = {}; 10872 VULKAN_HPP_NAMESPACE::Sampler m_sampler = {}; 10873 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 10874 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 10875 }; 10876 10877 class SamplerYcbcrConversion 10878 { 10879 public: 10880 using CType = VkSamplerYcbcrConversion; 10881 using CppType = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion; 10882 10883 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion; 10884 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 10885 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion; 10886 10887 public: 10888 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)10889 SamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10890 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 10891 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10892 { 10893 *this = device.createSamplerYcbcrConversion( createInfo, allocator ); 10894 } 10895 # endif 10896 SamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkSamplerYcbcrConversion ycbcrConversion,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)10897 SamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 10898 VkSamplerYcbcrConversion ycbcrConversion, 10899 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 10900 : m_device( device ) 10901 , m_ycbcrConversion( ycbcrConversion ) 10902 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 10903 , m_dispatcher( device.getDispatcher() ) 10904 { 10905 } 10906 SamplerYcbcrConversion(std::nullptr_t)10907 SamplerYcbcrConversion( std::nullptr_t ) {} 10908 ~SamplerYcbcrConversion()10909 ~SamplerYcbcrConversion() 10910 { 10911 clear(); 10912 } 10913 10914 SamplerYcbcrConversion() = delete; 10915 SamplerYcbcrConversion( SamplerYcbcrConversion const & ) = delete; 10916 SamplerYcbcrConversion(SamplerYcbcrConversion && rhs)10917 SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT 10918 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 10919 , m_ycbcrConversion( VULKAN_HPP_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ) ) 10920 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 10921 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 10922 { 10923 } 10924 10925 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & ) = delete; 10926 operator =(SamplerYcbcrConversion && rhs)10927 SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT 10928 { 10929 if ( this != &rhs ) 10930 { 10931 std::swap( m_device, rhs.m_device ); 10932 std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion ); 10933 std::swap( m_allocator, rhs.m_allocator ); 10934 std::swap( m_dispatcher, rhs.m_dispatcher ); 10935 } 10936 return *this; 10937 } 10938 operator *() const10939 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & operator*() const VULKAN_HPP_NOEXCEPT 10940 { 10941 return m_ycbcrConversion; 10942 } 10943 operator VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion() const10944 operator VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT 10945 { 10946 return m_ycbcrConversion; 10947 } 10948 clear()10949 void clear() VULKAN_HPP_NOEXCEPT 10950 { 10951 if ( m_ycbcrConversion ) 10952 { 10953 getDispatcher()->vkDestroySamplerYcbcrConversion( static_cast<VkDevice>( m_device ), 10954 static_cast<VkSamplerYcbcrConversion>( m_ycbcrConversion ), 10955 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 10956 } 10957 m_device = nullptr; 10958 m_ycbcrConversion = nullptr; 10959 m_allocator = nullptr; 10960 m_dispatcher = nullptr; 10961 } 10962 release()10963 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion release() 10964 { 10965 m_device = nullptr; 10966 m_allocator = nullptr; 10967 m_dispatcher = nullptr; 10968 return VULKAN_HPP_NAMESPACE::exchange( m_ycbcrConversion, nullptr ); 10969 } 10970 getDevice() const10971 VULKAN_HPP_NAMESPACE::Device getDevice() const 10972 { 10973 return m_device; 10974 } 10975 getDispatcher() const10976 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 10977 { 10978 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 10979 return m_dispatcher; 10980 } 10981 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion & rhs)10982 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion & rhs ) VULKAN_HPP_NOEXCEPT 10983 { 10984 std::swap( m_device, rhs.m_device ); 10985 std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion ); 10986 std::swap( m_allocator, rhs.m_allocator ); 10987 std::swap( m_dispatcher, rhs.m_dispatcher ); 10988 } 10989 10990 private: 10991 VULKAN_HPP_NAMESPACE::Device m_device = {}; 10992 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_ycbcrConversion = {}; 10993 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 10994 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 10995 }; 10996 10997 class Semaphore 10998 { 10999 public: 11000 using CType = VkSemaphore; 11001 using CppType = VULKAN_HPP_NAMESPACE::Semaphore; 11002 11003 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore; 11004 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 11005 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore; 11006 11007 public: 11008 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)11009 Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11010 VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo, 11011 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11012 { 11013 *this = device.createSemaphore( createInfo, allocator ); 11014 } 11015 # endif 11016 Semaphore(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkSemaphore semaphore,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)11017 Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11018 VkSemaphore semaphore, 11019 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11020 : m_device( device ) 11021 , m_semaphore( semaphore ) 11022 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 11023 , m_dispatcher( device.getDispatcher() ) 11024 { 11025 } 11026 Semaphore(std::nullptr_t)11027 Semaphore( std::nullptr_t ) {} 11028 ~Semaphore()11029 ~Semaphore() 11030 { 11031 clear(); 11032 } 11033 11034 Semaphore() = delete; 11035 Semaphore( Semaphore const & ) = delete; 11036 Semaphore(Semaphore && rhs)11037 Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT 11038 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 11039 , m_semaphore( VULKAN_HPP_NAMESPACE::exchange( rhs.m_semaphore, {} ) ) 11040 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 11041 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 11042 { 11043 } 11044 11045 Semaphore & operator=( Semaphore const & ) = delete; 11046 operator =(Semaphore && rhs)11047 Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT 11048 { 11049 if ( this != &rhs ) 11050 { 11051 std::swap( m_device, rhs.m_device ); 11052 std::swap( m_semaphore, rhs.m_semaphore ); 11053 std::swap( m_allocator, rhs.m_allocator ); 11054 std::swap( m_dispatcher, rhs.m_dispatcher ); 11055 } 11056 return *this; 11057 } 11058 operator *() const11059 VULKAN_HPP_NAMESPACE::Semaphore const & operator*() const VULKAN_HPP_NOEXCEPT 11060 { 11061 return m_semaphore; 11062 } 11063 operator VULKAN_HPP_NAMESPACE::Semaphore() const11064 operator VULKAN_HPP_NAMESPACE::Semaphore() const VULKAN_HPP_NOEXCEPT 11065 { 11066 return m_semaphore; 11067 } 11068 clear()11069 void clear() VULKAN_HPP_NOEXCEPT 11070 { 11071 if ( m_semaphore ) 11072 { 11073 getDispatcher()->vkDestroySemaphore( 11074 static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 11075 } 11076 m_device = nullptr; 11077 m_semaphore = nullptr; 11078 m_allocator = nullptr; 11079 m_dispatcher = nullptr; 11080 } 11081 release()11082 VULKAN_HPP_NAMESPACE::Semaphore release() 11083 { 11084 m_device = nullptr; 11085 m_allocator = nullptr; 11086 m_dispatcher = nullptr; 11087 return VULKAN_HPP_NAMESPACE::exchange( m_semaphore, nullptr ); 11088 } 11089 getDevice() const11090 VULKAN_HPP_NAMESPACE::Device getDevice() const 11091 { 11092 return m_device; 11093 } 11094 getDispatcher() const11095 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 11096 { 11097 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 11098 return m_dispatcher; 11099 } 11100 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore & rhs)11101 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore & rhs ) VULKAN_HPP_NOEXCEPT 11102 { 11103 std::swap( m_device, rhs.m_device ); 11104 std::swap( m_semaphore, rhs.m_semaphore ); 11105 std::swap( m_allocator, rhs.m_allocator ); 11106 std::swap( m_dispatcher, rhs.m_dispatcher ); 11107 } 11108 11109 //=== VK_VERSION_1_2 === 11110 11111 VULKAN_HPP_NODISCARD uint64_t getCounterValue() const; 11112 11113 //=== VK_KHR_timeline_semaphore === 11114 11115 VULKAN_HPP_NODISCARD uint64_t getCounterValueKHR() const; 11116 11117 private: 11118 VULKAN_HPP_NAMESPACE::Device m_device = {}; 11119 VULKAN_HPP_NAMESPACE::Semaphore m_semaphore = {}; 11120 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 11121 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 11122 }; 11123 11124 class ShaderEXT 11125 { 11126 public: 11127 using CType = VkShaderEXT; 11128 using CppType = VULKAN_HPP_NAMESPACE::ShaderEXT; 11129 11130 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT; 11131 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 11132 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 11133 11134 public: 11135 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) ShaderEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)11136 ShaderEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11137 VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo, 11138 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11139 { 11140 *this = device.createShaderEXT( createInfo, allocator ); 11141 } 11142 # endif 11143 ShaderEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkShaderEXT shader,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr,VULKAN_HPP_NAMESPACE::Result successCode=VULKAN_HPP_NAMESPACE::Result::eSuccess)11144 ShaderEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11145 VkShaderEXT shader, 11146 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr, 11147 VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess ) 11148 : m_device( device ) 11149 , m_shader( shader ) 11150 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 11151 , m_constructorSuccessCode( successCode ) 11152 , m_dispatcher( device.getDispatcher() ) 11153 { 11154 } 11155 ShaderEXT(std::nullptr_t)11156 ShaderEXT( std::nullptr_t ) {} 11157 ~ShaderEXT()11158 ~ShaderEXT() 11159 { 11160 clear(); 11161 } 11162 11163 ShaderEXT() = delete; 11164 ShaderEXT( ShaderEXT const & ) = delete; 11165 ShaderEXT(ShaderEXT && rhs)11166 ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT 11167 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 11168 , m_shader( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shader, {} ) ) 11169 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 11170 , m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) ) 11171 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 11172 { 11173 } 11174 11175 ShaderEXT & operator=( ShaderEXT const & ) = delete; 11176 operator =(ShaderEXT && rhs)11177 ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT 11178 { 11179 if ( this != &rhs ) 11180 { 11181 std::swap( m_device, rhs.m_device ); 11182 std::swap( m_shader, rhs.m_shader ); 11183 std::swap( m_allocator, rhs.m_allocator ); 11184 std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); 11185 std::swap( m_dispatcher, rhs.m_dispatcher ); 11186 } 11187 return *this; 11188 } 11189 operator *() const11190 VULKAN_HPP_NAMESPACE::ShaderEXT const & operator*() const VULKAN_HPP_NOEXCEPT 11191 { 11192 return m_shader; 11193 } 11194 operator VULKAN_HPP_NAMESPACE::ShaderEXT() const11195 operator VULKAN_HPP_NAMESPACE::ShaderEXT() const VULKAN_HPP_NOEXCEPT 11196 { 11197 return m_shader; 11198 } 11199 clear()11200 void clear() VULKAN_HPP_NOEXCEPT 11201 { 11202 if ( m_shader ) 11203 { 11204 getDispatcher()->vkDestroyShaderEXT( 11205 static_cast<VkDevice>( m_device ), static_cast<VkShaderEXT>( m_shader ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 11206 } 11207 m_device = nullptr; 11208 m_shader = nullptr; 11209 m_allocator = nullptr; 11210 m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; 11211 m_dispatcher = nullptr; 11212 } 11213 release()11214 VULKAN_HPP_NAMESPACE::ShaderEXT release() 11215 { 11216 m_device = nullptr; 11217 m_allocator = nullptr; 11218 m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; 11219 m_dispatcher = nullptr; 11220 return VULKAN_HPP_NAMESPACE::exchange( m_shader, nullptr ); 11221 } 11222 getConstructorSuccessCode() const11223 VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const 11224 { 11225 return m_constructorSuccessCode; 11226 } 11227 getDevice() const11228 VULKAN_HPP_NAMESPACE::Device getDevice() const 11229 { 11230 return m_device; 11231 } 11232 getDispatcher() const11233 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 11234 { 11235 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 11236 return m_dispatcher; 11237 } 11238 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT & rhs)11239 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT & rhs ) VULKAN_HPP_NOEXCEPT 11240 { 11241 std::swap( m_device, rhs.m_device ); 11242 std::swap( m_shader, rhs.m_shader ); 11243 std::swap( m_allocator, rhs.m_allocator ); 11244 std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); 11245 std::swap( m_dispatcher, rhs.m_dispatcher ); 11246 } 11247 11248 //=== VK_EXT_shader_object === 11249 11250 VULKAN_HPP_NODISCARD std::vector<uint8_t> getBinaryData() const; 11251 11252 private: 11253 VULKAN_HPP_NAMESPACE::Device m_device = {}; 11254 VULKAN_HPP_NAMESPACE::ShaderEXT m_shader = {}; 11255 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 11256 VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; 11257 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 11258 }; 11259 11260 class ShaderEXTs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT> 11261 { 11262 public: 11263 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) ShaderEXTs(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)11264 ShaderEXTs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11265 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, 11266 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11267 { 11268 *this = device.createShadersEXT( createInfos, allocator ); 11269 } 11270 # endif 11271 ShaderEXTs(std::nullptr_t)11272 ShaderEXTs( std::nullptr_t ) {} 11273 11274 ShaderEXTs() = delete; 11275 ShaderEXTs( ShaderEXTs const & ) = delete; 11276 ShaderEXTs( ShaderEXTs && rhs ) = default; 11277 ShaderEXTs & operator=( ShaderEXTs const & ) = delete; 11278 ShaderEXTs & operator=( ShaderEXTs && rhs ) = default; 11279 11280 private: ShaderEXTs(std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT> && rhs)11281 ShaderEXTs( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT> && rhs ) 11282 { 11283 std::swap( *this, rhs ); 11284 } 11285 }; 11286 11287 class ShaderModule 11288 { 11289 public: 11290 using CType = VkShaderModule; 11291 using CppType = VULKAN_HPP_NAMESPACE::ShaderModule; 11292 11293 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule; 11294 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 11295 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule; 11296 11297 public: 11298 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)11299 ShaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11300 VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo, 11301 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11302 { 11303 *this = device.createShaderModule( createInfo, allocator ); 11304 } 11305 # endif 11306 ShaderModule(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkShaderModule shaderModule,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)11307 ShaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11308 VkShaderModule shaderModule, 11309 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11310 : m_device( device ) 11311 , m_shaderModule( shaderModule ) 11312 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 11313 , m_dispatcher( device.getDispatcher() ) 11314 { 11315 } 11316 ShaderModule(std::nullptr_t)11317 ShaderModule( std::nullptr_t ) {} 11318 ~ShaderModule()11319 ~ShaderModule() 11320 { 11321 clear(); 11322 } 11323 11324 ShaderModule() = delete; 11325 ShaderModule( ShaderModule const & ) = delete; 11326 ShaderModule(ShaderModule && rhs)11327 ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT 11328 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 11329 , m_shaderModule( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderModule, {} ) ) 11330 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 11331 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 11332 { 11333 } 11334 11335 ShaderModule & operator=( ShaderModule const & ) = delete; 11336 operator =(ShaderModule && rhs)11337 ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT 11338 { 11339 if ( this != &rhs ) 11340 { 11341 std::swap( m_device, rhs.m_device ); 11342 std::swap( m_shaderModule, rhs.m_shaderModule ); 11343 std::swap( m_allocator, rhs.m_allocator ); 11344 std::swap( m_dispatcher, rhs.m_dispatcher ); 11345 } 11346 return *this; 11347 } 11348 operator *() const11349 VULKAN_HPP_NAMESPACE::ShaderModule const & operator*() const VULKAN_HPP_NOEXCEPT 11350 { 11351 return m_shaderModule; 11352 } 11353 operator VULKAN_HPP_NAMESPACE::ShaderModule() const11354 operator VULKAN_HPP_NAMESPACE::ShaderModule() const VULKAN_HPP_NOEXCEPT 11355 { 11356 return m_shaderModule; 11357 } 11358 clear()11359 void clear() VULKAN_HPP_NOEXCEPT 11360 { 11361 if ( m_shaderModule ) 11362 { 11363 getDispatcher()->vkDestroyShaderModule( 11364 static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( m_shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 11365 } 11366 m_device = nullptr; 11367 m_shaderModule = nullptr; 11368 m_allocator = nullptr; 11369 m_dispatcher = nullptr; 11370 } 11371 release()11372 VULKAN_HPP_NAMESPACE::ShaderModule release() 11373 { 11374 m_device = nullptr; 11375 m_allocator = nullptr; 11376 m_dispatcher = nullptr; 11377 return VULKAN_HPP_NAMESPACE::exchange( m_shaderModule, nullptr ); 11378 } 11379 getDevice() const11380 VULKAN_HPP_NAMESPACE::Device getDevice() const 11381 { 11382 return m_device; 11383 } 11384 getDispatcher() const11385 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 11386 { 11387 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 11388 return m_dispatcher; 11389 } 11390 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule & rhs)11391 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule & rhs ) VULKAN_HPP_NOEXCEPT 11392 { 11393 std::swap( m_device, rhs.m_device ); 11394 std::swap( m_shaderModule, rhs.m_shaderModule ); 11395 std::swap( m_allocator, rhs.m_allocator ); 11396 std::swap( m_dispatcher, rhs.m_dispatcher ); 11397 } 11398 11399 //=== VK_EXT_shader_module_identifier === 11400 11401 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT getIdentifierEXT() const VULKAN_HPP_NOEXCEPT; 11402 11403 private: 11404 VULKAN_HPP_NAMESPACE::Device m_device = {}; 11405 VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule = {}; 11406 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 11407 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 11408 }; 11409 11410 class SurfaceKHR 11411 { 11412 public: 11413 using CType = VkSurfaceKHR; 11414 using CppType = VULKAN_HPP_NAMESPACE::SurfaceKHR; 11415 11416 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR; 11417 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 11418 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR; 11419 11420 public: 11421 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11422 # 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)11423 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11424 VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo, 11425 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11426 { 11427 *this = instance.createAndroidSurfaceKHR( createInfo, allocator ); 11428 } 11429 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 11430 # endif 11431 11432 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11433 # 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)11434 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11435 VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo, 11436 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11437 { 11438 *this = instance.createDirectFBSurfaceEXT( createInfo, allocator ); 11439 } 11440 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 11441 # endif 11442 11443 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)11444 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11445 VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo, 11446 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11447 { 11448 *this = instance.createDisplayPlaneSurfaceKHR( createInfo, allocator ); 11449 } 11450 # endif 11451 11452 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)11453 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11454 VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo, 11455 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11456 { 11457 *this = instance.createHeadlessSurfaceEXT( createInfo, allocator ); 11458 } 11459 # endif 11460 11461 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11462 # 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)11463 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11464 VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo, 11465 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11466 { 11467 *this = instance.createIOSSurfaceMVK( createInfo, allocator ); 11468 } 11469 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 11470 # endif 11471 11472 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11473 # 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)11474 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11475 VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, 11476 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11477 { 11478 *this = instance.createImagePipeSurfaceFUCHSIA( createInfo, allocator ); 11479 } 11480 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 11481 # endif 11482 11483 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11484 # 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)11485 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11486 VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo, 11487 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11488 { 11489 *this = instance.createMacOSSurfaceMVK( createInfo, allocator ); 11490 } 11491 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 11492 # endif 11493 11494 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11495 # 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)11496 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11497 VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo, 11498 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11499 { 11500 *this = instance.createMetalSurfaceEXT( createInfo, allocator ); 11501 } 11502 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 11503 # endif 11504 11505 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11506 # 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)11507 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11508 VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, 11509 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11510 { 11511 *this = instance.createScreenSurfaceQNX( createInfo, allocator ); 11512 } 11513 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 11514 # endif 11515 11516 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11517 # 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)11518 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11519 VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, 11520 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11521 { 11522 *this = instance.createStreamDescriptorSurfaceGGP( createInfo, allocator ); 11523 } 11524 # endif /*VK_USE_PLATFORM_GGP*/ 11525 # endif 11526 11527 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11528 # 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)11529 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11530 VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, 11531 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11532 { 11533 *this = instance.createViSurfaceNN( createInfo, allocator ); 11534 } 11535 # endif /*VK_USE_PLATFORM_VI_NN*/ 11536 # endif 11537 11538 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11539 # 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)11540 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11541 VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo, 11542 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11543 { 11544 *this = instance.createWaylandSurfaceKHR( createInfo, allocator ); 11545 } 11546 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 11547 # endif 11548 11549 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11550 # 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)11551 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11552 VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo, 11553 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11554 { 11555 *this = instance.createWin32SurfaceKHR( createInfo, allocator ); 11556 } 11557 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 11558 # endif 11559 11560 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11561 # 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)11562 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11563 VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo, 11564 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11565 { 11566 *this = instance.createXcbSurfaceKHR( createInfo, allocator ); 11567 } 11568 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 11569 # endif 11570 11571 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 11572 # 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)11573 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11574 VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo, 11575 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11576 { 11577 *this = instance.createXlibSurfaceKHR( createInfo, allocator ); 11578 } 11579 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 11580 # endif 11581 SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,VkSurfaceKHR surface,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)11582 SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, 11583 VkSurfaceKHR surface, 11584 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11585 : m_instance( instance ) 11586 , m_surface( surface ) 11587 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 11588 , m_dispatcher( instance.getDispatcher() ) 11589 { 11590 } 11591 SurfaceKHR(std::nullptr_t)11592 SurfaceKHR( std::nullptr_t ) {} 11593 ~SurfaceKHR()11594 ~SurfaceKHR() 11595 { 11596 clear(); 11597 } 11598 11599 SurfaceKHR() = delete; 11600 SurfaceKHR( SurfaceKHR const & ) = delete; 11601 SurfaceKHR(SurfaceKHR && rhs)11602 SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT 11603 : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) 11604 , m_surface( VULKAN_HPP_NAMESPACE::exchange( rhs.m_surface, {} ) ) 11605 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 11606 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 11607 { 11608 } 11609 11610 SurfaceKHR & operator=( SurfaceKHR const & ) = delete; 11611 operator =(SurfaceKHR && rhs)11612 SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT 11613 { 11614 if ( this != &rhs ) 11615 { 11616 std::swap( m_instance, rhs.m_instance ); 11617 std::swap( m_surface, rhs.m_surface ); 11618 std::swap( m_allocator, rhs.m_allocator ); 11619 std::swap( m_dispatcher, rhs.m_dispatcher ); 11620 } 11621 return *this; 11622 } 11623 operator *() const11624 VULKAN_HPP_NAMESPACE::SurfaceKHR const & operator*() const VULKAN_HPP_NOEXCEPT 11625 { 11626 return m_surface; 11627 } 11628 operator VULKAN_HPP_NAMESPACE::SurfaceKHR() const11629 operator VULKAN_HPP_NAMESPACE::SurfaceKHR() const VULKAN_HPP_NOEXCEPT 11630 { 11631 return m_surface; 11632 } 11633 clear()11634 void clear() VULKAN_HPP_NOEXCEPT 11635 { 11636 if ( m_surface ) 11637 { 11638 getDispatcher()->vkDestroySurfaceKHR( 11639 static_cast<VkInstance>( m_instance ), static_cast<VkSurfaceKHR>( m_surface ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 11640 } 11641 m_instance = nullptr; 11642 m_surface = nullptr; 11643 m_allocator = nullptr; 11644 m_dispatcher = nullptr; 11645 } 11646 release()11647 VULKAN_HPP_NAMESPACE::SurfaceKHR release() 11648 { 11649 m_instance = nullptr; 11650 m_allocator = nullptr; 11651 m_dispatcher = nullptr; 11652 return VULKAN_HPP_NAMESPACE::exchange( m_surface, nullptr ); 11653 } 11654 getInstance() const11655 VULKAN_HPP_NAMESPACE::Instance getInstance() const 11656 { 11657 return m_instance; 11658 } 11659 getDispatcher() const11660 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const 11661 { 11662 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 11663 return m_dispatcher; 11664 } 11665 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR & rhs)11666 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR & rhs ) VULKAN_HPP_NOEXCEPT 11667 { 11668 std::swap( m_instance, rhs.m_instance ); 11669 std::swap( m_surface, rhs.m_surface ); 11670 std::swap( m_allocator, rhs.m_allocator ); 11671 std::swap( m_dispatcher, rhs.m_dispatcher ); 11672 } 11673 11674 private: 11675 VULKAN_HPP_NAMESPACE::Instance m_instance = {}; 11676 VULKAN_HPP_NAMESPACE::SurfaceKHR m_surface = {}; 11677 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 11678 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr; 11679 }; 11680 11681 class SwapchainKHR 11682 { 11683 public: 11684 using CType = VkSwapchainKHR; 11685 using CppType = VULKAN_HPP_NAMESPACE::SwapchainKHR; 11686 11687 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR; 11688 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 11689 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR; 11690 11691 public: 11692 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)11693 SwapchainKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11694 VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 11695 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11696 { 11697 *this = device.createSwapchainKHR( createInfo, allocator ); 11698 } 11699 # endif 11700 SwapchainKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkSwapchainKHR swapchain,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)11701 SwapchainKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11702 VkSwapchainKHR swapchain, 11703 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11704 : m_device( device ) 11705 , m_swapchain( swapchain ) 11706 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 11707 , m_dispatcher( device.getDispatcher() ) 11708 { 11709 } 11710 SwapchainKHR(std::nullptr_t)11711 SwapchainKHR( std::nullptr_t ) {} 11712 ~SwapchainKHR()11713 ~SwapchainKHR() 11714 { 11715 clear(); 11716 } 11717 11718 SwapchainKHR() = delete; 11719 SwapchainKHR( SwapchainKHR const & ) = delete; 11720 SwapchainKHR(SwapchainKHR && rhs)11721 SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT 11722 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 11723 , m_swapchain( VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchain, {} ) ) 11724 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 11725 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 11726 { 11727 } 11728 11729 SwapchainKHR & operator=( SwapchainKHR const & ) = delete; 11730 operator =(SwapchainKHR && rhs)11731 SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT 11732 { 11733 if ( this != &rhs ) 11734 { 11735 std::swap( m_device, rhs.m_device ); 11736 std::swap( m_swapchain, rhs.m_swapchain ); 11737 std::swap( m_allocator, rhs.m_allocator ); 11738 std::swap( m_dispatcher, rhs.m_dispatcher ); 11739 } 11740 return *this; 11741 } 11742 operator *() const11743 VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const VULKAN_HPP_NOEXCEPT 11744 { 11745 return m_swapchain; 11746 } 11747 operator VULKAN_HPP_NAMESPACE::SwapchainKHR() const11748 operator VULKAN_HPP_NAMESPACE::SwapchainKHR() const VULKAN_HPP_NOEXCEPT 11749 { 11750 return m_swapchain; 11751 } 11752 clear()11753 void clear() VULKAN_HPP_NOEXCEPT 11754 { 11755 if ( m_swapchain ) 11756 { 11757 getDispatcher()->vkDestroySwapchainKHR( 11758 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 11759 } 11760 m_device = nullptr; 11761 m_swapchain = nullptr; 11762 m_allocator = nullptr; 11763 m_dispatcher = nullptr; 11764 } 11765 release()11766 VULKAN_HPP_NAMESPACE::SwapchainKHR release() 11767 { 11768 m_device = nullptr; 11769 m_allocator = nullptr; 11770 m_dispatcher = nullptr; 11771 return VULKAN_HPP_NAMESPACE::exchange( m_swapchain, nullptr ); 11772 } 11773 getDevice() const11774 VULKAN_HPP_NAMESPACE::Device getDevice() const 11775 { 11776 return m_device; 11777 } 11778 getDispatcher() const11779 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 11780 { 11781 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 11782 return m_dispatcher; 11783 } 11784 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR & rhs)11785 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR & rhs ) VULKAN_HPP_NOEXCEPT 11786 { 11787 std::swap( m_device, rhs.m_device ); 11788 std::swap( m_swapchain, rhs.m_swapchain ); 11789 std::swap( m_allocator, rhs.m_allocator ); 11790 std::swap( m_dispatcher, rhs.m_dispatcher ); 11791 } 11792 11793 //=== VK_KHR_swapchain === 11794 11795 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Image> getImages() const; 11796 11797 VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> 11798 acquireNextImage( uint64_t timeout, 11799 VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, 11800 VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const; 11801 11802 //=== VK_EXT_display_control === 11803 11804 VULKAN_HPP_NODISCARD uint64_t getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const; 11805 11806 //=== VK_GOOGLE_display_timing === 11807 11808 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE getRefreshCycleDurationGOOGLE() const; 11809 11810 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> getPastPresentationTimingGOOGLE() const; 11811 11812 //=== VK_KHR_shared_presentable_image === 11813 11814 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getStatus() const; 11815 11816 //=== VK_AMD_display_native_hdr === 11817 11818 void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT; 11819 11820 //=== VK_KHR_present_wait === 11821 11822 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresent( uint64_t presentId, uint64_t timeout ) const; 11823 11824 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 11825 //=== VK_EXT_full_screen_exclusive === 11826 11827 void acquireFullScreenExclusiveModeEXT() const; 11828 11829 void releaseFullScreenExclusiveModeEXT() const; 11830 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 11831 11832 //=== VK_NV_low_latency2 === 11833 11834 void setLatencySleepModeNV( const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo ) const; 11835 11836 void latencySleepNV( const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo ) const VULKAN_HPP_NOEXCEPT; 11837 11838 void setLatencyMarkerNV( const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT; 11839 11840 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV> getLatencyTimingsNV() const; 11841 11842 private: 11843 VULKAN_HPP_NAMESPACE::Device m_device = {}; 11844 VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {}; 11845 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 11846 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 11847 }; 11848 11849 class SwapchainKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> 11850 { 11851 public: 11852 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)11853 SwapchainKHRs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11854 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, 11855 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11856 { 11857 *this = device.createSharedSwapchainsKHR( createInfos, allocator ); 11858 } 11859 # endif 11860 SwapchainKHRs(std::nullptr_t)11861 SwapchainKHRs( std::nullptr_t ) {} 11862 11863 SwapchainKHRs() = delete; 11864 SwapchainKHRs( SwapchainKHRs const & ) = delete; 11865 SwapchainKHRs( SwapchainKHRs && rhs ) = default; 11866 SwapchainKHRs & operator=( SwapchainKHRs const & ) = delete; 11867 SwapchainKHRs & operator=( SwapchainKHRs && rhs ) = default; 11868 11869 private: SwapchainKHRs(std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> && rhs)11870 SwapchainKHRs( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> && rhs ) 11871 { 11872 std::swap( *this, rhs ); 11873 } 11874 }; 11875 11876 class ValidationCacheEXT 11877 { 11878 public: 11879 using CType = VkValidationCacheEXT; 11880 using CppType = VULKAN_HPP_NAMESPACE::ValidationCacheEXT; 11881 11882 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT; 11883 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 11884 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT; 11885 11886 public: 11887 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)11888 ValidationCacheEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11889 VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo, 11890 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11891 { 11892 *this = device.createValidationCacheEXT( createInfo, allocator ); 11893 } 11894 # endif 11895 ValidationCacheEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkValidationCacheEXT validationCache,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)11896 ValidationCacheEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 11897 VkValidationCacheEXT validationCache, 11898 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 11899 : m_device( device ) 11900 , m_validationCache( validationCache ) 11901 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 11902 , m_dispatcher( device.getDispatcher() ) 11903 { 11904 } 11905 ValidationCacheEXT(std::nullptr_t)11906 ValidationCacheEXT( std::nullptr_t ) {} 11907 ~ValidationCacheEXT()11908 ~ValidationCacheEXT() 11909 { 11910 clear(); 11911 } 11912 11913 ValidationCacheEXT() = delete; 11914 ValidationCacheEXT( ValidationCacheEXT const & ) = delete; 11915 ValidationCacheEXT(ValidationCacheEXT && rhs)11916 ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT 11917 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 11918 , m_validationCache( VULKAN_HPP_NAMESPACE::exchange( rhs.m_validationCache, {} ) ) 11919 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 11920 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 11921 { 11922 } 11923 11924 ValidationCacheEXT & operator=( ValidationCacheEXT const & ) = delete; 11925 operator =(ValidationCacheEXT && rhs)11926 ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT 11927 { 11928 if ( this != &rhs ) 11929 { 11930 std::swap( m_device, rhs.m_device ); 11931 std::swap( m_validationCache, rhs.m_validationCache ); 11932 std::swap( m_allocator, rhs.m_allocator ); 11933 std::swap( m_dispatcher, rhs.m_dispatcher ); 11934 } 11935 return *this; 11936 } 11937 operator *() const11938 VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const VULKAN_HPP_NOEXCEPT 11939 { 11940 return m_validationCache; 11941 } 11942 operator VULKAN_HPP_NAMESPACE::ValidationCacheEXT() const11943 operator VULKAN_HPP_NAMESPACE::ValidationCacheEXT() const VULKAN_HPP_NOEXCEPT 11944 { 11945 return m_validationCache; 11946 } 11947 clear()11948 void clear() VULKAN_HPP_NOEXCEPT 11949 { 11950 if ( m_validationCache ) 11951 { 11952 getDispatcher()->vkDestroyValidationCacheEXT( static_cast<VkDevice>( m_device ), 11953 static_cast<VkValidationCacheEXT>( m_validationCache ), 11954 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 11955 } 11956 m_device = nullptr; 11957 m_validationCache = nullptr; 11958 m_allocator = nullptr; 11959 m_dispatcher = nullptr; 11960 } 11961 release()11962 VULKAN_HPP_NAMESPACE::ValidationCacheEXT release() 11963 { 11964 m_device = nullptr; 11965 m_allocator = nullptr; 11966 m_dispatcher = nullptr; 11967 return VULKAN_HPP_NAMESPACE::exchange( m_validationCache, nullptr ); 11968 } 11969 getDevice() const11970 VULKAN_HPP_NAMESPACE::Device getDevice() const 11971 { 11972 return m_device; 11973 } 11974 getDispatcher() const11975 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 11976 { 11977 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 11978 return m_dispatcher; 11979 } 11980 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT & rhs)11981 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT & rhs ) VULKAN_HPP_NOEXCEPT 11982 { 11983 std::swap( m_device, rhs.m_device ); 11984 std::swap( m_validationCache, rhs.m_validationCache ); 11985 std::swap( m_allocator, rhs.m_allocator ); 11986 std::swap( m_dispatcher, rhs.m_dispatcher ); 11987 } 11988 11989 //=== VK_EXT_validation_cache === 11990 11991 void merge( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const; 11992 11993 VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const; 11994 11995 private: 11996 VULKAN_HPP_NAMESPACE::Device m_device = {}; 11997 VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCache = {}; 11998 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 11999 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 12000 }; 12001 12002 class VideoSessionKHR 12003 { 12004 public: 12005 using CType = VkVideoSessionKHR; 12006 using CppType = VULKAN_HPP_NAMESPACE::VideoSessionKHR; 12007 12008 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR; 12009 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 12010 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 12011 12012 public: 12013 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)12014 VideoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 12015 VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, 12016 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 12017 { 12018 *this = device.createVideoSessionKHR( createInfo, allocator ); 12019 } 12020 # endif 12021 VideoSessionKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkVideoSessionKHR videoSession,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)12022 VideoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 12023 VkVideoSessionKHR videoSession, 12024 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 12025 : m_device( device ) 12026 , m_videoSession( videoSession ) 12027 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 12028 , m_dispatcher( device.getDispatcher() ) 12029 { 12030 } 12031 VideoSessionKHR(std::nullptr_t)12032 VideoSessionKHR( std::nullptr_t ) {} 12033 ~VideoSessionKHR()12034 ~VideoSessionKHR() 12035 { 12036 clear(); 12037 } 12038 12039 VideoSessionKHR() = delete; 12040 VideoSessionKHR( VideoSessionKHR const & ) = delete; 12041 VideoSessionKHR(VideoSessionKHR && rhs)12042 VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT 12043 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 12044 , m_videoSession( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSession, {} ) ) 12045 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 12046 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 12047 { 12048 } 12049 12050 VideoSessionKHR & operator=( VideoSessionKHR const & ) = delete; 12051 operator =(VideoSessionKHR && rhs)12052 VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT 12053 { 12054 if ( this != &rhs ) 12055 { 12056 std::swap( m_device, rhs.m_device ); 12057 std::swap( m_videoSession, rhs.m_videoSession ); 12058 std::swap( m_allocator, rhs.m_allocator ); 12059 std::swap( m_dispatcher, rhs.m_dispatcher ); 12060 } 12061 return *this; 12062 } 12063 operator *() const12064 VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const VULKAN_HPP_NOEXCEPT 12065 { 12066 return m_videoSession; 12067 } 12068 operator VULKAN_HPP_NAMESPACE::VideoSessionKHR() const12069 operator VULKAN_HPP_NAMESPACE::VideoSessionKHR() const VULKAN_HPP_NOEXCEPT 12070 { 12071 return m_videoSession; 12072 } 12073 clear()12074 void clear() VULKAN_HPP_NOEXCEPT 12075 { 12076 if ( m_videoSession ) 12077 { 12078 getDispatcher()->vkDestroyVideoSessionKHR( static_cast<VkDevice>( m_device ), 12079 static_cast<VkVideoSessionKHR>( m_videoSession ), 12080 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 12081 } 12082 m_device = nullptr; 12083 m_videoSession = nullptr; 12084 m_allocator = nullptr; 12085 m_dispatcher = nullptr; 12086 } 12087 release()12088 VULKAN_HPP_NAMESPACE::VideoSessionKHR release() 12089 { 12090 m_device = nullptr; 12091 m_allocator = nullptr; 12092 m_dispatcher = nullptr; 12093 return VULKAN_HPP_NAMESPACE::exchange( m_videoSession, nullptr ); 12094 } 12095 getDevice() const12096 VULKAN_HPP_NAMESPACE::Device getDevice() const 12097 { 12098 return m_device; 12099 } 12100 getDispatcher() const12101 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 12102 { 12103 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 12104 return m_dispatcher; 12105 } 12106 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR & rhs)12107 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR & rhs ) VULKAN_HPP_NOEXCEPT 12108 { 12109 std::swap( m_device, rhs.m_device ); 12110 std::swap( m_videoSession, rhs.m_videoSession ); 12111 std::swap( m_allocator, rhs.m_allocator ); 12112 std::swap( m_dispatcher, rhs.m_dispatcher ); 12113 } 12114 12115 //=== VK_KHR_video_queue === 12116 12117 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> getMemoryRequirements() const; 12118 12119 void bindMemory( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos ) const; 12120 12121 private: 12122 VULKAN_HPP_NAMESPACE::Device m_device = {}; 12123 VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSession = {}; 12124 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 12125 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 12126 }; 12127 12128 class VideoSessionParametersKHR 12129 { 12130 public: 12131 using CType = VkVideoSessionParametersKHR; 12132 using CppType = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR; 12133 12134 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR; 12135 static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = 12136 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; 12137 12138 public: 12139 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 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)12140 VideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 12141 VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo, 12142 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 12143 { 12144 *this = device.createVideoSessionParametersKHR( createInfo, allocator ); 12145 } 12146 # endif 12147 VideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,VkVideoSessionParametersKHR videoSessionParameters,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator=nullptr)12148 VideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, 12149 VkVideoSessionParametersKHR videoSessionParameters, 12150 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) 12151 : m_device( device ) 12152 , m_videoSessionParameters( videoSessionParameters ) 12153 , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) 12154 , m_dispatcher( device.getDispatcher() ) 12155 { 12156 } 12157 VideoSessionParametersKHR(std::nullptr_t)12158 VideoSessionParametersKHR( std::nullptr_t ) {} 12159 ~VideoSessionParametersKHR()12160 ~VideoSessionParametersKHR() 12161 { 12162 clear(); 12163 } 12164 12165 VideoSessionParametersKHR() = delete; 12166 VideoSessionParametersKHR( VideoSessionParametersKHR const & ) = delete; 12167 VideoSessionParametersKHR(VideoSessionParametersKHR && rhs)12168 VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT 12169 : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) 12170 , m_videoSessionParameters( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} ) ) 12171 , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) 12172 , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) 12173 { 12174 } 12175 12176 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & ) = delete; 12177 operator =(VideoSessionParametersKHR && rhs)12178 VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT 12179 { 12180 if ( this != &rhs ) 12181 { 12182 std::swap( m_device, rhs.m_device ); 12183 std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters ); 12184 std::swap( m_allocator, rhs.m_allocator ); 12185 std::swap( m_dispatcher, rhs.m_dispatcher ); 12186 } 12187 return *this; 12188 } 12189 operator *() const12190 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const VULKAN_HPP_NOEXCEPT 12191 { 12192 return m_videoSessionParameters; 12193 } 12194 operator VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR() const12195 operator VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT 12196 { 12197 return m_videoSessionParameters; 12198 } 12199 clear()12200 void clear() VULKAN_HPP_NOEXCEPT 12201 { 12202 if ( m_videoSessionParameters ) 12203 { 12204 getDispatcher()->vkDestroyVideoSessionParametersKHR( static_cast<VkDevice>( m_device ), 12205 static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ), 12206 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) ); 12207 } 12208 m_device = nullptr; 12209 m_videoSessionParameters = nullptr; 12210 m_allocator = nullptr; 12211 m_dispatcher = nullptr; 12212 } 12213 release()12214 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR release() 12215 { 12216 m_device = nullptr; 12217 m_allocator = nullptr; 12218 m_dispatcher = nullptr; 12219 return VULKAN_HPP_NAMESPACE::exchange( m_videoSessionParameters, nullptr ); 12220 } 12221 getDevice() const12222 VULKAN_HPP_NAMESPACE::Device getDevice() const 12223 { 12224 return m_device; 12225 } 12226 getDispatcher() const12227 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const 12228 { 12229 VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); 12230 return m_dispatcher; 12231 } 12232 swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR & rhs)12233 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR & rhs ) VULKAN_HPP_NOEXCEPT 12234 { 12235 std::swap( m_device, rhs.m_device ); 12236 std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters ); 12237 std::swap( m_allocator, rhs.m_allocator ); 12238 std::swap( m_dispatcher, rhs.m_dispatcher ); 12239 } 12240 12241 //=== VK_KHR_video_queue === 12242 12243 void update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const; 12244 12245 private: 12246 VULKAN_HPP_NAMESPACE::Device m_device = {}; 12247 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParameters = {}; 12248 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; 12249 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; 12250 }; 12251 12252 //=========================== 12253 //=== COMMAND Definitions === 12254 //=========================== 12255 12256 //=== VK_VERSION_1_0 === 12257 12258 VULKAN_HPP_NODISCARD 12259 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance>::Type createInstance(VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12260 Context::createInstance( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo, 12261 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 12262 { 12263 VULKAN_HPP_NAMESPACE::Instance instance; 12264 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateInstance( 12265 reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ), 12266 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 12267 reinterpret_cast<VkInstance *>( &instance ) ) ); 12268 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12269 { 12270 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 12271 return VULKAN_HPP_UNEXPECTED( result ); 12272 # else 12273 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Context::createInstance" ); 12274 # endif 12275 } 12276 12277 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance( *this, *reinterpret_cast<VkInstance *>( &instance ), allocator ); 12278 } 12279 12280 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 12281 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice>>::Type enumeratePhysicalDevices() const12282 Instance::enumeratePhysicalDevices() const 12283 { 12284 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice> physicalDevices; 12285 uint32_t physicalDeviceCount; 12286 VULKAN_HPP_NAMESPACE::Result result; 12287 do 12288 { 12289 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12290 getDispatcher()->vkEnumeratePhysicalDevices( static_cast<VkInstance>( m_instance ), &physicalDeviceCount, nullptr ) ); 12291 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceCount ) 12292 { 12293 physicalDevices.resize( physicalDeviceCount ); 12294 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDevices( 12295 static_cast<VkInstance>( m_instance ), &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) ); 12296 } 12297 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12298 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncomplete ) ) 12299 { 12300 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 12301 return VULKAN_HPP_UNEXPECTED( result ); 12302 # else 12303 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::enumeratePhysicalDevices" ); 12304 # endif 12305 } 12306 12307 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> physicalDevicesRAII; 12308 physicalDevicesRAII.reserve( physicalDevices.size() ); 12309 for ( auto & physicalDevice : physicalDevices ) 12310 { 12311 physicalDevicesRAII.emplace_back( *this, *reinterpret_cast<VkPhysicalDevice *>( &physicalDevice ) ); 12312 } 12313 return physicalDevicesRAII; 12314 } 12315 getFeatures() const12316 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT 12317 { 12318 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures && "Function <vkGetPhysicalDeviceFeatures> requires <VK_VERSION_1_0>" ); 12319 12320 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features; 12321 getDispatcher()->vkGetPhysicalDeviceFeatures( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12322 reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) ); 12323 12324 return features; 12325 } 12326 12327 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties getFormatProperties(VULKAN_HPP_NAMESPACE::Format format) const12328 PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 12329 { 12330 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties && "Function <vkGetPhysicalDeviceFormatProperties> requires <VK_VERSION_1_0>" ); 12331 12332 VULKAN_HPP_NAMESPACE::FormatProperties formatProperties; 12333 getDispatcher()->vkGetPhysicalDeviceFormatProperties( 12334 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) ); 12335 12336 return formatProperties; 12337 } 12338 12339 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) const12340 PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, 12341 VULKAN_HPP_NAMESPACE::ImageType type, 12342 VULKAN_HPP_NAMESPACE::ImageTiling tiling, 12343 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 12344 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags ) const 12345 { 12346 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties && 12347 "Function <vkGetPhysicalDeviceImageFormatProperties> requires <VK_VERSION_1_0>" ); 12348 12349 VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties; 12350 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12351 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12352 static_cast<VkFormat>( format ), 12353 static_cast<VkImageType>( type ), 12354 static_cast<VkImageTiling>( tiling ), 12355 static_cast<VkImageUsageFlags>( usage ), 12356 static_cast<VkImageCreateFlags>( flags ), 12357 reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) ); 12358 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); 12359 12360 return imageFormatProperties; 12361 } 12362 getProperties() const12363 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties PhysicalDevice::getProperties() const VULKAN_HPP_NOEXCEPT 12364 { 12365 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties && "Function <vkGetPhysicalDeviceProperties> requires <VK_VERSION_1_0>" ); 12366 12367 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties; 12368 getDispatcher()->vkGetPhysicalDeviceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12369 reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) ); 12370 12371 return properties; 12372 } 12373 getQueueFamilyProperties() const12374 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> PhysicalDevice::getQueueFamilyProperties() const 12375 { 12376 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties && 12377 "Function <vkGetPhysicalDeviceQueueFamilyProperties> requires <VK_VERSION_1_0>" ); 12378 12379 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> queueFamilyProperties; 12380 uint32_t queueFamilyPropertyCount; 12381 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 12382 queueFamilyProperties.resize( queueFamilyPropertyCount ); 12383 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12384 &queueFamilyPropertyCount, 12385 reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) ); 12386 12387 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); 12388 if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) 12389 { 12390 queueFamilyProperties.resize( queueFamilyPropertyCount ); 12391 } 12392 return queueFamilyProperties; 12393 } 12394 getMemoryProperties() const12395 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties() const VULKAN_HPP_NOEXCEPT 12396 { 12397 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties && "Function <vkGetPhysicalDeviceMemoryProperties> requires <VK_VERSION_1_0>" ); 12398 12399 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties; 12400 getDispatcher()->vkGetPhysicalDeviceMemoryProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12401 reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) ); 12402 12403 return memoryProperties; 12404 } 12405 getProcAddr(const std::string & name) const12406 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT 12407 { 12408 VULKAN_HPP_ASSERT( getDispatcher()->vkGetInstanceProcAddr && "Function <vkGetInstanceProcAddr> requires <VK_VERSION_1_0>" ); 12409 12410 PFN_vkVoidFunction result = getDispatcher()->vkGetInstanceProcAddr( static_cast<VkInstance>( m_instance ), name.c_str() ); 12411 12412 return result; 12413 } 12414 getProcAddr(const std::string & name) const12415 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT 12416 { 12417 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceProcAddr && "Function <vkGetDeviceProcAddr> requires <VK_VERSION_1_0>" ); 12418 12419 PFN_vkVoidFunction result = getDispatcher()->vkGetDeviceProcAddr( static_cast<VkDevice>( m_device ), name.c_str() ); 12420 12421 return result; 12422 } 12423 12424 VULKAN_HPP_NODISCARD 12425 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device>::Type createDevice(VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12426 PhysicalDevice::createDevice( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo, 12427 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 12428 VULKAN_HPP_RAII_CREATE_NOEXCEPT 12429 { 12430 VULKAN_HPP_NAMESPACE::Device device; 12431 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDevice( 12432 static_cast<VkPhysicalDevice>( m_physicalDevice ), 12433 reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ), 12434 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 12435 reinterpret_cast<VkDevice *>( &device ) ) ); 12436 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12437 { 12438 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 12439 return VULKAN_HPP_UNEXPECTED( result ); 12440 # else 12441 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::createDevice" ); 12442 # endif 12443 } 12444 12445 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device( *this, *reinterpret_cast<VkDevice *>( &device ), allocator ); 12446 } 12447 12448 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> enumerateInstanceExtensionProperties(Optional<const std::string> layerName) const12449 Context::enumerateInstanceExtensionProperties( Optional<const std::string> layerName ) const 12450 { 12451 VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceExtensionProperties && 12452 "Function <vkEnumerateInstanceExtensionProperties> requires <VK_VERSION_1_0>" ); 12453 12454 std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties; 12455 uint32_t propertyCount; 12456 VULKAN_HPP_NAMESPACE::Result result; 12457 do 12458 { 12459 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12460 getDispatcher()->vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); 12461 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 12462 { 12463 properties.resize( propertyCount ); 12464 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceExtensionProperties( 12465 layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); 12466 } 12467 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12468 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceExtensionProperties" ); 12469 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 12470 if ( propertyCount < properties.size() ) 12471 { 12472 properties.resize( propertyCount ); 12473 } 12474 return properties; 12475 } 12476 12477 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> enumerateDeviceExtensionProperties(Optional<const std::string> layerName) const12478 PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName ) const 12479 { 12480 VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateDeviceExtensionProperties && "Function <vkEnumerateDeviceExtensionProperties> requires <VK_VERSION_1_0>" ); 12481 12482 std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties; 12483 uint32_t propertyCount; 12484 VULKAN_HPP_NAMESPACE::Result result; 12485 do 12486 { 12487 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateDeviceExtensionProperties( 12488 static_cast<VkPhysicalDevice>( m_physicalDevice ), layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); 12489 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 12490 { 12491 properties.resize( propertyCount ); 12492 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12493 getDispatcher()->vkEnumerateDeviceExtensionProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12494 layerName ? layerName->c_str() : nullptr, 12495 &propertyCount, 12496 reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) ); 12497 } 12498 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12499 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); 12500 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 12501 if ( propertyCount < properties.size() ) 12502 { 12503 properties.resize( propertyCount ); 12504 } 12505 return properties; 12506 } 12507 enumerateInstanceLayerProperties() const12508 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> Context::enumerateInstanceLayerProperties() const 12509 { 12510 VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceLayerProperties && "Function <vkEnumerateInstanceLayerProperties> requires <VK_VERSION_1_0>" ); 12511 12512 std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties; 12513 uint32_t propertyCount; 12514 VULKAN_HPP_NAMESPACE::Result result; 12515 do 12516 { 12517 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); 12518 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 12519 { 12520 properties.resize( propertyCount ); 12521 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12522 getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); 12523 } 12524 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12525 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceLayerProperties" ); 12526 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 12527 if ( propertyCount < properties.size() ) 12528 { 12529 properties.resize( propertyCount ); 12530 } 12531 return properties; 12532 } 12533 enumerateDeviceLayerProperties() const12534 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> PhysicalDevice::enumerateDeviceLayerProperties() const 12535 { 12536 VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateDeviceLayerProperties && "Function <vkEnumerateDeviceLayerProperties> requires <VK_VERSION_1_0>" ); 12537 12538 std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties; 12539 uint32_t propertyCount; 12540 VULKAN_HPP_NAMESPACE::Result result; 12541 do 12542 { 12543 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12544 getDispatcher()->vkEnumerateDeviceLayerProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 12545 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 12546 { 12547 properties.resize( propertyCount ); 12548 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateDeviceLayerProperties( 12549 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) ); 12550 } 12551 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 12552 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); 12553 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 12554 if ( propertyCount < properties.size() ) 12555 { 12556 properties.resize( propertyCount ); 12557 } 12558 return properties; 12559 } 12560 12561 VULKAN_HPP_NODISCARD 12562 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue>::Type getQueue(uint32_t queueFamilyIndex,uint32_t queueIndex) const12563 Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 12564 { 12565 VULKAN_HPP_NAMESPACE::Queue queue; 12566 getDispatcher()->vkGetDeviceQueue( static_cast<VkDevice>( m_device ), queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &queue ) ); 12567 12568 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue( *this, *reinterpret_cast<VkQueue *>( &queue ) ); 12569 } 12570 submit(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,VULKAN_HPP_NAMESPACE::Fence fence) const12571 VULKAN_HPP_INLINE void Queue::submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits, 12572 VULKAN_HPP_NAMESPACE::Fence fence ) const 12573 { 12574 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit && "Function <vkQueueSubmit> requires <VK_VERSION_1_0>" ); 12575 12576 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSubmit( 12577 static_cast<VkQueue>( m_queue ), submits.size(), reinterpret_cast<const VkSubmitInfo *>( submits.data() ), static_cast<VkFence>( fence ) ) ); 12578 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" ); 12579 } 12580 waitIdle() const12581 VULKAN_HPP_INLINE void Queue::waitIdle() const 12582 { 12583 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueWaitIdle && "Function <vkQueueWaitIdle> requires <VK_VERSION_1_0>" ); 12584 12585 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueWaitIdle( static_cast<VkQueue>( m_queue ) ) ); 12586 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" ); 12587 } 12588 waitIdle() const12589 VULKAN_HPP_INLINE void Device::waitIdle() const 12590 { 12591 VULKAN_HPP_ASSERT( getDispatcher()->vkDeviceWaitIdle && "Function <vkDeviceWaitIdle> requires <VK_VERSION_1_0>" ); 12592 12593 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDeviceWaitIdle( static_cast<VkDevice>( m_device ) ) ); 12594 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" ); 12595 } 12596 12597 VULKAN_HPP_NODISCARD 12598 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory>::Type allocateMemory(VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12599 Device::allocateMemory( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo, 12600 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 12601 { 12602 VULKAN_HPP_NAMESPACE::DeviceMemory memory; 12603 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAllocateMemory( 12604 static_cast<VkDevice>( m_device ), 12605 reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ), 12606 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 12607 reinterpret_cast<VkDeviceMemory *>( &memory ) ) ); 12608 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12609 { 12610 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 12611 return VULKAN_HPP_UNEXPECTED( result ); 12612 # else 12613 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::allocateMemory" ); 12614 # endif 12615 } 12616 12617 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory( *this, *reinterpret_cast<VkDeviceMemory *>( &memory ), allocator ); 12618 } 12619 mapMemory(VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::DeviceSize size,VULKAN_HPP_NAMESPACE::MemoryMapFlags flags) const12620 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * DeviceMemory::mapMemory( VULKAN_HPP_NAMESPACE::DeviceSize offset, 12621 VULKAN_HPP_NAMESPACE::DeviceSize size, 12622 VULKAN_HPP_NAMESPACE::MemoryMapFlags flags ) const 12623 { 12624 VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory && "Function <vkMapMemory> requires <VK_VERSION_1_0>" ); 12625 12626 void * pData; 12627 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkMapMemory( static_cast<VkDevice>( m_device ), 12628 static_cast<VkDeviceMemory>( m_memory ), 12629 static_cast<VkDeviceSize>( offset ), 12630 static_cast<VkDeviceSize>( size ), 12631 static_cast<VkMemoryMapFlags>( flags ), 12632 &pData ) ); 12633 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory" ); 12634 12635 return pData; 12636 } 12637 unmapMemory() const12638 VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT 12639 { 12640 VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory && "Function <vkUnmapMemory> requires <VK_VERSION_1_0>" ); 12641 12642 getDispatcher()->vkUnmapMemory( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ) ); 12643 } 12644 12645 VULKAN_HPP_INLINE void flushMappedMemoryRanges(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges) const12646 Device::flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const 12647 { 12648 VULKAN_HPP_ASSERT( getDispatcher()->vkFlushMappedMemoryRanges && "Function <vkFlushMappedMemoryRanges> requires <VK_VERSION_1_0>" ); 12649 12650 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkFlushMappedMemoryRanges( 12651 static_cast<VkDevice>( m_device ), memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) ); 12652 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); 12653 } 12654 12655 VULKAN_HPP_INLINE void invalidateMappedMemoryRanges(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges) const12656 Device::invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const 12657 { 12658 VULKAN_HPP_ASSERT( getDispatcher()->vkInvalidateMappedMemoryRanges && "Function <vkInvalidateMappedMemoryRanges> requires <VK_VERSION_1_0>" ); 12659 12660 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInvalidateMappedMemoryRanges( 12661 static_cast<VkDevice>( m_device ), memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) ); 12662 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); 12663 } 12664 getCommitment() const12665 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT 12666 { 12667 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryCommitment && "Function <vkGetDeviceMemoryCommitment> requires <VK_VERSION_1_0>" ); 12668 12669 VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes; 12670 getDispatcher()->vkGetDeviceMemoryCommitment( 12671 static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) ); 12672 12673 return committedMemoryInBytes; 12674 } 12675 bindMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory,VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset) const12676 VULKAN_HPP_INLINE void Buffer::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const 12677 { 12678 VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory && "Function <vkBindBufferMemory> requires <VK_VERSION_1_0>" ); 12679 12680 VULKAN_HPP_NAMESPACE::Result result = 12681 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindBufferMemory( static_cast<VkDevice>( m_device ), 12682 static_cast<VkBuffer>( m_buffer ), 12683 static_cast<VkDeviceMemory>( memory ), 12684 static_cast<VkDeviceSize>( memoryOffset ) ) ); 12685 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Buffer::bindMemory" ); 12686 } 12687 bindMemory(VULKAN_HPP_NAMESPACE::DeviceMemory memory,VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset) const12688 VULKAN_HPP_INLINE void Image::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const 12689 { 12690 VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory && "Function <vkBindImageMemory> requires <VK_VERSION_1_0>" ); 12691 12692 VULKAN_HPP_NAMESPACE::Result result = 12693 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindImageMemory( static_cast<VkDevice>( m_device ), 12694 static_cast<VkImage>( m_image ), 12695 static_cast<VkDeviceMemory>( memory ), 12696 static_cast<VkDeviceSize>( memoryOffset ) ) ); 12697 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Image::bindMemory" ); 12698 } 12699 getMemoryRequirements() const12700 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT 12701 { 12702 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements && "Function <vkGetBufferMemoryRequirements> requires <VK_VERSION_1_0>" ); 12703 12704 VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; 12705 getDispatcher()->vkGetBufferMemoryRequirements( 12706 static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( m_buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) ); 12707 12708 return memoryRequirements; 12709 } 12710 getMemoryRequirements() const12711 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT 12712 { 12713 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements && "Function <vkGetImageMemoryRequirements> requires <VK_VERSION_1_0>" ); 12714 12715 VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements; 12716 getDispatcher()->vkGetImageMemoryRequirements( 12717 static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) ); 12718 12719 return memoryRequirements; 12720 } 12721 getSparseMemoryRequirements() const12722 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> Image::getSparseMemoryRequirements() const 12723 { 12724 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements && "Function <vkGetImageSparseMemoryRequirements> requires <VK_VERSION_1_0>" ); 12725 12726 std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements; 12727 uint32_t sparseMemoryRequirementCount; 12728 getDispatcher()->vkGetImageSparseMemoryRequirements( 12729 static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr ); 12730 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 12731 getDispatcher()->vkGetImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ), 12732 static_cast<VkImage>( m_image ), 12733 &sparseMemoryRequirementCount, 12734 reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) ); 12735 12736 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); 12737 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) 12738 { 12739 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 12740 } 12741 return sparseMemoryRequirements; 12742 } 12743 12744 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) const12745 PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format, 12746 VULKAN_HPP_NAMESPACE::ImageType type, 12747 VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, 12748 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 12749 VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const 12750 { 12751 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties && 12752 "Function <vkGetPhysicalDeviceSparseImageFormatProperties> requires <VK_VERSION_1_0>" ); 12753 12754 std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> properties; 12755 uint32_t propertyCount; 12756 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12757 static_cast<VkFormat>( format ), 12758 static_cast<VkImageType>( type ), 12759 static_cast<VkSampleCountFlagBits>( samples ), 12760 static_cast<VkImageUsageFlags>( usage ), 12761 static_cast<VkImageTiling>( tiling ), 12762 &propertyCount, 12763 nullptr ); 12764 properties.resize( propertyCount ); 12765 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 12766 static_cast<VkFormat>( format ), 12767 static_cast<VkImageType>( type ), 12768 static_cast<VkSampleCountFlagBits>( samples ), 12769 static_cast<VkImageUsageFlags>( usage ), 12770 static_cast<VkImageTiling>( tiling ), 12771 &propertyCount, 12772 reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) ); 12773 12774 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 12775 if ( propertyCount < properties.size() ) 12776 { 12777 properties.resize( propertyCount ); 12778 } 12779 return properties; 12780 } 12781 bindSparse(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,VULKAN_HPP_NAMESPACE::Fence fence) const12782 VULKAN_HPP_INLINE void Queue::bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo, 12783 VULKAN_HPP_NAMESPACE::Fence fence ) const 12784 { 12785 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBindSparse && "Function <vkQueueBindSparse> requires <VK_VERSION_1_0>" ); 12786 12787 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueBindSparse( 12788 static_cast<VkQueue>( m_queue ), bindInfo.size(), reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ), static_cast<VkFence>( fence ) ) ); 12789 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" ); 12790 } 12791 12792 VULKAN_HPP_NODISCARD 12793 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type createFence(VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12794 Device::createFence( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo, 12795 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 12796 { 12797 VULKAN_HPP_NAMESPACE::Fence fence; 12798 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateFence( 12799 static_cast<VkDevice>( m_device ), 12800 reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ), 12801 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 12802 reinterpret_cast<VkFence *>( &fence ) ) ); 12803 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12804 { 12805 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 12806 return VULKAN_HPP_UNEXPECTED( result ); 12807 # else 12808 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createFence" ); 12809 # endif 12810 } 12811 12812 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence( *this, *reinterpret_cast<VkFence *>( &fence ), allocator ); 12813 } 12814 resetFences(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences) const12815 VULKAN_HPP_INLINE void Device::resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const 12816 { 12817 VULKAN_HPP_ASSERT( getDispatcher()->vkResetFences && "Function <vkResetFences> requires <VK_VERSION_1_0>" ); 12818 12819 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 12820 getDispatcher()->vkResetFences( static_cast<VkDevice>( m_device ), fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) ); 12821 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" ); 12822 } 12823 getStatus() const12824 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Fence::getStatus() const 12825 { 12826 VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceStatus && "Function <vkGetFenceStatus> requires <VK_VERSION_1_0>" ); 12827 12828 VULKAN_HPP_NAMESPACE::Result result = 12829 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceStatus( static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ) ) ); 12830 VULKAN_HPP_NAMESPACE::detail::resultCheck( 12831 result, VULKAN_HPP_NAMESPACE_STRING "::Fence::getStatus", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); 12832 12833 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 12834 } 12835 waitForFences(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,VULKAN_HPP_NAMESPACE::Bool32 waitAll,uint64_t timeout) const12836 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitForFences( 12837 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout ) const 12838 { 12839 VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForFences && "Function <vkWaitForFences> requires <VK_VERSION_1_0>" ); 12840 12841 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitForFences( 12842 static_cast<VkDevice>( m_device ), fences.size(), reinterpret_cast<const VkFence *>( fences.data() ), static_cast<VkBool32>( waitAll ), timeout ) ); 12843 VULKAN_HPP_NAMESPACE::detail::resultCheck( 12844 result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); 12845 12846 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 12847 } 12848 12849 VULKAN_HPP_NODISCARD 12850 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore>::Type createSemaphore(VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12851 Device::createSemaphore( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo, 12852 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 12853 { 12854 VULKAN_HPP_NAMESPACE::Semaphore semaphore; 12855 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSemaphore( 12856 static_cast<VkDevice>( m_device ), 12857 reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ), 12858 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 12859 reinterpret_cast<VkSemaphore *>( &semaphore ) ) ); 12860 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12861 { 12862 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 12863 return VULKAN_HPP_UNEXPECTED( result ); 12864 # else 12865 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSemaphore" ); 12866 # endif 12867 } 12868 12869 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore( *this, *reinterpret_cast<VkSemaphore *>( &semaphore ), allocator ); 12870 } 12871 12872 VULKAN_HPP_NODISCARD 12873 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event>::Type createEvent(VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12874 Device::createEvent( VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo, 12875 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 12876 { 12877 VULKAN_HPP_NAMESPACE::Event event; 12878 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateEvent( 12879 static_cast<VkDevice>( m_device ), 12880 reinterpret_cast<const VkEventCreateInfo *>( &createInfo ), 12881 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 12882 reinterpret_cast<VkEvent *>( &event ) ) ); 12883 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12884 { 12885 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 12886 return VULKAN_HPP_UNEXPECTED( result ); 12887 # else 12888 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createEvent" ); 12889 # endif 12890 } 12891 12892 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event( *this, *reinterpret_cast<VkEvent *>( &event ), allocator ); 12893 } 12894 getStatus() const12895 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Event::getStatus() const 12896 { 12897 VULKAN_HPP_ASSERT( getDispatcher()->vkGetEventStatus && "Function <vkGetEventStatus> requires <VK_VERSION_1_0>" ); 12898 12899 VULKAN_HPP_NAMESPACE::Result result = 12900 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEventStatus( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) ); 12901 VULKAN_HPP_NAMESPACE::detail::resultCheck( 12902 result, VULKAN_HPP_NAMESPACE_STRING "::Event::getStatus", { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } ); 12903 12904 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 12905 } 12906 set() const12907 VULKAN_HPP_INLINE void Event::set() const 12908 { 12909 VULKAN_HPP_ASSERT( getDispatcher()->vkSetEvent && "Function <vkSetEvent> requires <VK_VERSION_1_0>" ); 12910 12911 VULKAN_HPP_NAMESPACE::Result result = 12912 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) ); 12913 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Event::set" ); 12914 } 12915 reset() const12916 VULKAN_HPP_INLINE void Event::reset() const 12917 { 12918 VULKAN_HPP_ASSERT( getDispatcher()->vkResetEvent && "Function <vkResetEvent> requires <VK_VERSION_1_0>" ); 12919 12920 VULKAN_HPP_NAMESPACE::Result result = 12921 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) ); 12922 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Event::reset" ); 12923 } 12924 12925 VULKAN_HPP_NODISCARD 12926 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool>::Type createQueryPool(VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12927 Device::createQueryPool( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo, 12928 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 12929 { 12930 VULKAN_HPP_NAMESPACE::QueryPool queryPool; 12931 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateQueryPool( 12932 static_cast<VkDevice>( m_device ), 12933 reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ), 12934 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 12935 reinterpret_cast<VkQueryPool *>( &queryPool ) ) ); 12936 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 12937 { 12938 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 12939 return VULKAN_HPP_UNEXPECTED( result ); 12940 # else 12941 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createQueryPool" ); 12942 # endif 12943 } 12944 12945 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool( *this, *reinterpret_cast<VkQueryPool *>( &queryPool ), allocator ); 12946 } 12947 12948 template <typename DataType> getResults(uint32_t firstQuery,uint32_t queryCount,size_t dataSize,VULKAN_HPP_NAMESPACE::DeviceSize stride,VULKAN_HPP_NAMESPACE::QueryResultFlags flags) const12949 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>> QueryPool::getResults( 12950 uint32_t firstQuery, uint32_t queryCount, size_t dataSize, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const 12951 { 12952 VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" ); 12953 12954 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); 12955 std::vector<DataType> data( dataSize / sizeof( DataType ) ); 12956 VULKAN_HPP_NAMESPACE::Result result = 12957 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ), 12958 static_cast<VkQueryPool>( m_queryPool ), 12959 firstQuery, 12960 queryCount, 12961 data.size() * sizeof( DataType ), 12962 reinterpret_cast<void *>( data.data() ), 12963 static_cast<VkDeviceSize>( stride ), 12964 static_cast<VkQueryResultFlags>( flags ) ) ); 12965 VULKAN_HPP_NAMESPACE::detail::resultCheck( 12966 result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResults", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); 12967 12968 return std::make_pair( result, std::move( data ) ); 12969 } 12970 12971 template <typename DataType> getResult(uint32_t firstQuery,uint32_t queryCount,VULKAN_HPP_NAMESPACE::DeviceSize stride,VULKAN_HPP_NAMESPACE::QueryResultFlags flags) const12972 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, DataType> QueryPool::getResult( 12973 uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const 12974 { 12975 VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" ); 12976 12977 DataType data; 12978 VULKAN_HPP_NAMESPACE::Result result = 12979 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ), 12980 static_cast<VkQueryPool>( m_queryPool ), 12981 firstQuery, 12982 queryCount, 12983 sizeof( DataType ), 12984 reinterpret_cast<void *>( &data ), 12985 static_cast<VkDeviceSize>( stride ), 12986 static_cast<VkQueryResultFlags>( flags ) ) ); 12987 VULKAN_HPP_NAMESPACE::detail::resultCheck( 12988 result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResult", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } ); 12989 12990 return std::make_pair( result, std::move( data ) ); 12991 } 12992 12993 VULKAN_HPP_NODISCARD 12994 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer>::Type createBuffer(VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const12995 Device::createBuffer( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo, 12996 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 12997 { 12998 VULKAN_HPP_NAMESPACE::Buffer buffer; 12999 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateBuffer( 13000 static_cast<VkDevice>( m_device ), 13001 reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ), 13002 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13003 reinterpret_cast<VkBuffer *>( &buffer ) ) ); 13004 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13005 { 13006 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13007 return VULKAN_HPP_UNEXPECTED( result ); 13008 # else 13009 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createBuffer" ); 13010 # endif 13011 } 13012 13013 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer( *this, *reinterpret_cast<VkBuffer *>( &buffer ), allocator ); 13014 } 13015 13016 VULKAN_HPP_NODISCARD 13017 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView>::Type createBufferView(VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13018 Device::createBufferView( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo, 13019 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13020 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13021 { 13022 VULKAN_HPP_NAMESPACE::BufferView view; 13023 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateBufferView( 13024 static_cast<VkDevice>( m_device ), 13025 reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ), 13026 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13027 reinterpret_cast<VkBufferView *>( &view ) ) ); 13028 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13029 { 13030 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13031 return VULKAN_HPP_UNEXPECTED( result ); 13032 # else 13033 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createBufferView" ); 13034 # endif 13035 } 13036 13037 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView( *this, *reinterpret_cast<VkBufferView *>( &view ), allocator ); 13038 } 13039 13040 VULKAN_HPP_NODISCARD 13041 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image>::Type createImage(VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13042 Device::createImage( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo, 13043 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 13044 { 13045 VULKAN_HPP_NAMESPACE::Image image; 13046 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateImage( 13047 static_cast<VkDevice>( m_device ), 13048 reinterpret_cast<const VkImageCreateInfo *>( &createInfo ), 13049 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13050 reinterpret_cast<VkImage *>( &image ) ) ); 13051 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13052 { 13053 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13054 return VULKAN_HPP_UNEXPECTED( result ); 13055 # else 13056 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createImage" ); 13057 # endif 13058 } 13059 13060 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image( *this, *reinterpret_cast<VkImage *>( &image ), allocator ); 13061 } 13062 13063 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout getSubresourceLayout(const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource) const13064 Image::getSubresourceLayout( const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT 13065 { 13066 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSubresourceLayout && "Function <vkGetImageSubresourceLayout> requires <VK_VERSION_1_0>" ); 13067 13068 VULKAN_HPP_NAMESPACE::SubresourceLayout layout; 13069 getDispatcher()->vkGetImageSubresourceLayout( static_cast<VkDevice>( m_device ), 13070 static_cast<VkImage>( m_image ), 13071 reinterpret_cast<const VkImageSubresource *>( &subresource ), 13072 reinterpret_cast<VkSubresourceLayout *>( &layout ) ); 13073 13074 return layout; 13075 } 13076 13077 VULKAN_HPP_NODISCARD 13078 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView>::Type createImageView(VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13079 Device::createImageView( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo, 13080 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 13081 { 13082 VULKAN_HPP_NAMESPACE::ImageView view; 13083 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateImageView( 13084 static_cast<VkDevice>( m_device ), 13085 reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ), 13086 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13087 reinterpret_cast<VkImageView *>( &view ) ) ); 13088 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13089 { 13090 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13091 return VULKAN_HPP_UNEXPECTED( result ); 13092 # else 13093 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createImageView" ); 13094 # endif 13095 } 13096 13097 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView( *this, *reinterpret_cast<VkImageView *>( &view ), allocator ); 13098 } 13099 13100 VULKAN_HPP_NODISCARD 13101 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule>::Type createShaderModule(VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13102 Device::createShaderModule( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo, 13103 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13104 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13105 { 13106 VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; 13107 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateShaderModule( 13108 static_cast<VkDevice>( m_device ), 13109 reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ), 13110 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13111 reinterpret_cast<VkShaderModule *>( &shaderModule ) ) ); 13112 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13113 { 13114 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13115 return VULKAN_HPP_UNEXPECTED( result ); 13116 # else 13117 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createShaderModule" ); 13118 # endif 13119 } 13120 13121 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule( *this, *reinterpret_cast<VkShaderModule *>( &shaderModule ), allocator ); 13122 } 13123 13124 VULKAN_HPP_NODISCARD 13125 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache>::Type createPipelineCache(VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13126 Device::createPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo, 13127 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13128 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13129 { 13130 VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; 13131 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineCache( 13132 static_cast<VkDevice>( m_device ), 13133 reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ), 13134 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13135 reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) ); 13136 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13137 { 13138 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13139 return VULKAN_HPP_UNEXPECTED( result ); 13140 # else 13141 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPipelineCache" ); 13142 # endif 13143 } 13144 13145 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache( *this, *reinterpret_cast<VkPipelineCache *>( &pipelineCache ), allocator ); 13146 } 13147 getData() const13148 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> PipelineCache::getData() const 13149 { 13150 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineCacheData && "Function <vkGetPipelineCacheData> requires <VK_VERSION_1_0>" ); 13151 13152 std::vector<uint8_t> data; 13153 size_t dataSize; 13154 VULKAN_HPP_NAMESPACE::Result result; 13155 do 13156 { 13157 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 13158 getDispatcher()->vkGetPipelineCacheData( static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, nullptr ) ); 13159 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) 13160 { 13161 data.resize( dataSize ); 13162 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineCacheData( 13163 static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) ); 13164 } 13165 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 13166 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::getData" ); 13167 VULKAN_HPP_ASSERT( dataSize <= data.size() ); 13168 if ( dataSize < data.size() ) 13169 { 13170 data.resize( dataSize ); 13171 } 13172 return data; 13173 } 13174 merge(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches) const13175 VULKAN_HPP_INLINE void PipelineCache::merge( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const 13176 { 13177 VULKAN_HPP_ASSERT( getDispatcher()->vkMergePipelineCaches && "Function <vkMergePipelineCaches> requires <VK_VERSION_1_0>" ); 13178 13179 VULKAN_HPP_NAMESPACE::Result result = 13180 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkMergePipelineCaches( static_cast<VkDevice>( m_device ), 13181 static_cast<VkPipelineCache>( m_pipelineCache ), 13182 srcCaches.size(), 13183 reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) ); 13184 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::merge" ); 13185 } 13186 13187 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 13188 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type 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) const13189 Device::createGraphicsPipelines( 13190 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 13191 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos, 13192 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13193 { 13194 std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); 13195 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateGraphicsPipelines( 13196 static_cast<VkDevice>( m_device ), 13197 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 13198 createInfos.size(), 13199 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ), 13200 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13201 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); 13202 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 13203 { 13204 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13205 return VULKAN_HPP_UNEXPECTED( result ); 13206 # else 13207 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createGraphicsPipelines" ); 13208 # endif 13209 } 13210 13211 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII; 13212 pipelinesRAII.reserve( pipelines.size() ); 13213 for ( auto & pipeline : pipelines ) 13214 { 13215 pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 13216 } 13217 return pipelinesRAII; 13218 } 13219 13220 VULKAN_HPP_NODISCARD 13221 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type 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) const13222 Device::createGraphicsPipeline( 13223 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 13224 VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo, 13225 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 13226 { 13227 VULKAN_HPP_NAMESPACE::Pipeline pipeline; 13228 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateGraphicsPipelines( 13229 static_cast<VkDevice>( m_device ), 13230 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 13231 1, 13232 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ), 13233 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13234 reinterpret_cast<VkPipeline *>( &pipeline ) ) ); 13235 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 13236 { 13237 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13238 return VULKAN_HPP_UNEXPECTED( result ); 13239 # else 13240 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createGraphicsPipeline" ); 13241 # endif 13242 } 13243 13244 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 13245 } 13246 13247 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 13248 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type 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) const13249 Device::createComputePipelines( 13250 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 13251 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos, 13252 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13253 { 13254 std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); 13255 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateComputePipelines( 13256 static_cast<VkDevice>( m_device ), 13257 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 13258 createInfos.size(), 13259 reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ), 13260 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13261 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); 13262 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 13263 { 13264 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13265 return VULKAN_HPP_UNEXPECTED( result ); 13266 # else 13267 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createComputePipelines" ); 13268 # endif 13269 } 13270 13271 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII; 13272 pipelinesRAII.reserve( pipelines.size() ); 13273 for ( auto & pipeline : pipelines ) 13274 { 13275 pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 13276 } 13277 return pipelinesRAII; 13278 } 13279 13280 VULKAN_HPP_NODISCARD 13281 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type 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) const13282 Device::createComputePipeline( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 13283 VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo, 13284 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13285 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13286 { 13287 VULKAN_HPP_NAMESPACE::Pipeline pipeline; 13288 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateComputePipelines( 13289 static_cast<VkDevice>( m_device ), 13290 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 13291 1, 13292 reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), 13293 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13294 reinterpret_cast<VkPipeline *>( &pipeline ) ) ); 13295 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 13296 { 13297 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13298 return VULKAN_HPP_UNEXPECTED( result ); 13299 # else 13300 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createComputePipeline" ); 13301 # endif 13302 } 13303 13304 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 13305 } 13306 13307 VULKAN_HPP_NODISCARD 13308 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout>::Type createPipelineLayout(VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13309 Device::createPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo, 13310 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13311 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13312 { 13313 VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; 13314 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineLayout( 13315 static_cast<VkDevice>( m_device ), 13316 reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ), 13317 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13318 reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) ); 13319 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13320 { 13321 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13322 return VULKAN_HPP_UNEXPECTED( result ); 13323 # else 13324 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPipelineLayout" ); 13325 # endif 13326 } 13327 13328 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout( *this, *reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ), allocator ); 13329 } 13330 13331 VULKAN_HPP_NODISCARD 13332 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler>::Type createSampler(VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13333 Device::createSampler( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo, 13334 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 13335 { 13336 VULKAN_HPP_NAMESPACE::Sampler sampler; 13337 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSampler( 13338 static_cast<VkDevice>( m_device ), 13339 reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ), 13340 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13341 reinterpret_cast<VkSampler *>( &sampler ) ) ); 13342 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13343 { 13344 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13345 return VULKAN_HPP_UNEXPECTED( result ); 13346 # else 13347 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSampler" ); 13348 # endif 13349 } 13350 13351 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler( *this, *reinterpret_cast<VkSampler *>( &sampler ), allocator ); 13352 } 13353 13354 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 13355 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout>::Type createDescriptorSetLayout(VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13356 Device::createDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo, 13357 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13358 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13359 { 13360 VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; 13361 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDescriptorSetLayout( 13362 static_cast<VkDevice>( m_device ), 13363 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 13364 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13365 reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) ); 13366 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13367 { 13368 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13369 return VULKAN_HPP_UNEXPECTED( result ); 13370 # else 13371 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDescriptorSetLayout" ); 13372 # endif 13373 } 13374 13375 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout( *this, *reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ), allocator ); 13376 } 13377 13378 VULKAN_HPP_NODISCARD 13379 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool>::Type createDescriptorPool(VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13380 Device::createDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo, 13381 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13382 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13383 { 13384 VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; 13385 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDescriptorPool( 13386 static_cast<VkDevice>( m_device ), 13387 reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ), 13388 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13389 reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) ); 13390 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13391 { 13392 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13393 return VULKAN_HPP_UNEXPECTED( result ); 13394 # else 13395 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDescriptorPool" ); 13396 # endif 13397 } 13398 13399 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool( *this, *reinterpret_cast<VkDescriptorPool *>( &descriptorPool ), allocator ); 13400 } 13401 reset(VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags) const13402 VULKAN_HPP_INLINE void DescriptorPool::reset( VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT 13403 { 13404 VULKAN_HPP_ASSERT( getDispatcher()->vkResetDescriptorPool && "Function <vkResetDescriptorPool> requires <VK_VERSION_1_0>" ); 13405 13406 getDispatcher()->vkResetDescriptorPool( 13407 static_cast<VkDevice>( m_device ), static_cast<VkDescriptorPool>( m_descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ); 13408 } 13409 13410 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 13411 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>>::Type allocateDescriptorSets(VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo) const13412 Device::allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const 13413 { 13414 std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount ); 13415 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 13416 getDispatcher()->vkAllocateDescriptorSets( static_cast<VkDevice>( m_device ), 13417 reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), 13418 reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) ); 13419 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13420 { 13421 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13422 return VULKAN_HPP_UNEXPECTED( result ); 13423 # else 13424 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::allocateDescriptorSets" ); 13425 # endif 13426 } 13427 13428 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> descriptorSetsRAII; 13429 descriptorSetsRAII.reserve( descriptorSets.size() ); 13430 for ( auto & descriptorSet : descriptorSets ) 13431 { 13432 descriptorSetsRAII.emplace_back( 13433 *this, *reinterpret_cast<VkDescriptorSet *>( &descriptorSet ), static_cast<VkDescriptorPool>( allocateInfo.descriptorPool ) ); 13434 } 13435 return descriptorSetsRAII; 13436 } 13437 updateDescriptorSets(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies) const13438 VULKAN_HPP_INLINE void Device::updateDescriptorSets( 13439 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites, 13440 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT 13441 { 13442 VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSets && "Function <vkUpdateDescriptorSets> requires <VK_VERSION_1_0>" ); 13443 13444 getDispatcher()->vkUpdateDescriptorSets( static_cast<VkDevice>( m_device ), 13445 descriptorWrites.size(), 13446 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ), 13447 descriptorCopies.size(), 13448 reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) ); 13449 } 13450 13451 VULKAN_HPP_NODISCARD 13452 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer>::Type createFramebuffer(VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13453 Device::createFramebuffer( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo, 13454 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13455 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13456 { 13457 VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; 13458 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateFramebuffer( 13459 static_cast<VkDevice>( m_device ), 13460 reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ), 13461 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13462 reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) ); 13463 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13464 { 13465 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13466 return VULKAN_HPP_UNEXPECTED( result ); 13467 # else 13468 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createFramebuffer" ); 13469 # endif 13470 } 13471 13472 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer( *this, *reinterpret_cast<VkFramebuffer *>( &framebuffer ), allocator ); 13473 } 13474 13475 VULKAN_HPP_NODISCARD 13476 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type createRenderPass(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13477 Device::createRenderPass( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo, 13478 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13479 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13480 { 13481 VULKAN_HPP_NAMESPACE::RenderPass renderPass; 13482 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRenderPass( 13483 static_cast<VkDevice>( m_device ), 13484 reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ), 13485 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13486 reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); 13487 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13488 { 13489 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13490 return VULKAN_HPP_UNEXPECTED( result ); 13491 # else 13492 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRenderPass" ); 13493 # endif 13494 } 13495 13496 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, *reinterpret_cast<VkRenderPass *>( &renderPass ), allocator ); 13497 } 13498 getRenderAreaGranularity() const13499 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT 13500 { 13501 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderAreaGranularity && "Function <vkGetRenderAreaGranularity> requires <VK_VERSION_1_0>" ); 13502 13503 VULKAN_HPP_NAMESPACE::Extent2D granularity; 13504 getDispatcher()->vkGetRenderAreaGranularity( 13505 static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) ); 13506 13507 return granularity; 13508 } 13509 13510 VULKAN_HPP_NODISCARD 13511 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool>::Type createCommandPool(VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const13512 Device::createCommandPool( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo, 13513 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 13514 VULKAN_HPP_RAII_CREATE_NOEXCEPT 13515 { 13516 VULKAN_HPP_NAMESPACE::CommandPool commandPool; 13517 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCommandPool( 13518 static_cast<VkDevice>( m_device ), 13519 reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ), 13520 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 13521 reinterpret_cast<VkCommandPool *>( &commandPool ) ) ); 13522 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13523 { 13524 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13525 return VULKAN_HPP_UNEXPECTED( result ); 13526 # else 13527 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCommandPool" ); 13528 # endif 13529 } 13530 13531 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool( *this, *reinterpret_cast<VkCommandPool *>( &commandPool ), allocator ); 13532 } 13533 reset(VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags) const13534 VULKAN_HPP_INLINE void CommandPool::reset( VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags ) const 13535 { 13536 VULKAN_HPP_ASSERT( getDispatcher()->vkResetCommandPool && "Function <vkResetCommandPool> requires <VK_VERSION_1_0>" ); 13537 13538 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetCommandPool( 13539 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) ); 13540 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandPool::reset" ); 13541 } 13542 13543 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 13544 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>>::Type allocateCommandBuffers(VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo) const13545 Device::allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const 13546 { 13547 std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer> commandBuffers( allocateInfo.commandBufferCount ); 13548 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 13549 getDispatcher()->vkAllocateCommandBuffers( static_cast<VkDevice>( m_device ), 13550 reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), 13551 reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) ); 13552 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 13553 { 13554 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 13555 return VULKAN_HPP_UNEXPECTED( result ); 13556 # else 13557 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::allocateCommandBuffers" ); 13558 # endif 13559 } 13560 13561 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> commandBuffersRAII; 13562 commandBuffersRAII.reserve( commandBuffers.size() ); 13563 for ( auto & commandBuffer : commandBuffers ) 13564 { 13565 commandBuffersRAII.emplace_back( 13566 *this, *reinterpret_cast<VkCommandBuffer *>( &commandBuffer ), static_cast<VkCommandPool>( allocateInfo.commandPool ) ); 13567 } 13568 return commandBuffersRAII; 13569 } 13570 begin(const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo) const13571 VULKAN_HPP_INLINE void CommandBuffer::begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const 13572 { 13573 VULKAN_HPP_ASSERT( getDispatcher()->vkBeginCommandBuffer && "Function <vkBeginCommandBuffer> requires <VK_VERSION_1_0>" ); 13574 13575 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBeginCommandBuffer( 13576 static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) ); 13577 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" ); 13578 } 13579 end() const13580 VULKAN_HPP_INLINE void CommandBuffer::end() const 13581 { 13582 VULKAN_HPP_ASSERT( getDispatcher()->vkEndCommandBuffer && "Function <vkEndCommandBuffer> requires <VK_VERSION_1_0>" ); 13583 13584 VULKAN_HPP_NAMESPACE::Result result = 13585 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEndCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ) ) ); 13586 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" ); 13587 } 13588 reset(VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags) const13589 VULKAN_HPP_INLINE void CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags ) const 13590 { 13591 VULKAN_HPP_ASSERT( getDispatcher()->vkResetCommandBuffer && "Function <vkResetCommandBuffer> requires <VK_VERSION_1_0>" ); 13592 13593 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 13594 getDispatcher()->vkResetCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCommandBufferResetFlags>( flags ) ) ); 13595 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" ); 13596 } 13597 bindPipeline(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::Pipeline pipeline) const13598 VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 13599 VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT 13600 { 13601 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindPipeline && "Function <vkCmdBindPipeline> requires <VK_VERSION_1_0>" ); 13602 13603 getDispatcher()->vkCmdBindPipeline( 13604 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) ); 13605 } 13606 13607 VULKAN_HPP_INLINE void setViewport(uint32_t firstViewport,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports) const13608 CommandBuffer::setViewport( uint32_t firstViewport, 13609 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT 13610 { 13611 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewport && "Function <vkCmdSetViewport> requires <VK_VERSION_1_0>" ); 13612 13613 getDispatcher()->vkCmdSetViewport( 13614 static_cast<VkCommandBuffer>( m_commandBuffer ), firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) ); 13615 } 13616 13617 VULKAN_HPP_INLINE void setScissor(uint32_t firstScissor,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors) const13618 CommandBuffer::setScissor( uint32_t firstScissor, 13619 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT 13620 { 13621 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissor && "Function <vkCmdSetScissor> requires <VK_VERSION_1_0>" ); 13622 13623 getDispatcher()->vkCmdSetScissor( 13624 static_cast<VkCommandBuffer>( m_commandBuffer ), firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) ); 13625 } 13626 setLineWidth(float lineWidth) const13627 VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT 13628 { 13629 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineWidth && "Function <vkCmdSetLineWidth> requires <VK_VERSION_1_0>" ); 13630 13631 getDispatcher()->vkCmdSetLineWidth( static_cast<VkCommandBuffer>( m_commandBuffer ), lineWidth ); 13632 } 13633 13634 VULKAN_HPP_INLINE void setDepthBias(float depthBiasConstantFactor,float depthBiasClamp,float depthBiasSlopeFactor) const13635 CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT 13636 { 13637 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBias && "Function <vkCmdSetDepthBias> requires <VK_VERSION_1_0>" ); 13638 13639 getDispatcher()->vkCmdSetDepthBias( static_cast<VkCommandBuffer>( m_commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); 13640 } 13641 setBlendConstants(const float blendConstants[4]) const13642 VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT 13643 { 13644 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetBlendConstants && "Function <vkCmdSetBlendConstants> requires <VK_VERSION_1_0>" ); 13645 13646 getDispatcher()->vkCmdSetBlendConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), blendConstants ); 13647 } 13648 setDepthBounds(float minDepthBounds,float maxDepthBounds) const13649 VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT 13650 { 13651 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBounds && "Function <vkCmdSetDepthBounds> requires <VK_VERSION_1_0>" ); 13652 13653 getDispatcher()->vkCmdSetDepthBounds( static_cast<VkCommandBuffer>( m_commandBuffer ), minDepthBounds, maxDepthBounds ); 13654 } 13655 setStencilCompareMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,uint32_t compareMask) const13656 VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 13657 uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT 13658 { 13659 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilCompareMask && "Function <vkCmdSetStencilCompareMask> requires <VK_VERSION_1_0>" ); 13660 13661 getDispatcher()->vkCmdSetStencilCompareMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), compareMask ); 13662 } 13663 setStencilWriteMask(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,uint32_t writeMask) const13664 VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT 13665 { 13666 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilWriteMask && "Function <vkCmdSetStencilWriteMask> requires <VK_VERSION_1_0>" ); 13667 13668 getDispatcher()->vkCmdSetStencilWriteMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), writeMask ); 13669 } 13670 setStencilReference(VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,uint32_t reference) const13671 VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT 13672 { 13673 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilReference && "Function <vkCmdSetStencilReference> requires <VK_VERSION_1_0>" ); 13674 13675 getDispatcher()->vkCmdSetStencilReference( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), reference ); 13676 } 13677 13678 VULKAN_HPP_INLINE void bindDescriptorSets(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t firstSet,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets) const13679 CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 13680 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 13681 uint32_t firstSet, 13682 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets, 13683 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT 13684 { 13685 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets && "Function <vkCmdBindDescriptorSets> requires <VK_VERSION_1_0>" ); 13686 13687 getDispatcher()->vkCmdBindDescriptorSets( static_cast<VkCommandBuffer>( m_commandBuffer ), 13688 static_cast<VkPipelineBindPoint>( pipelineBindPoint ), 13689 static_cast<VkPipelineLayout>( layout ), 13690 firstSet, 13691 descriptorSets.size(), 13692 reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ), 13693 dynamicOffsets.size(), 13694 dynamicOffsets.data() ); 13695 } 13696 bindIndexBuffer(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::IndexType indexType) const13697 VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, 13698 VULKAN_HPP_NAMESPACE::DeviceSize offset, 13699 VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT 13700 { 13701 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer && "Function <vkCmdBindIndexBuffer> requires <VK_VERSION_1_0>" ); 13702 13703 getDispatcher()->vkCmdBindIndexBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 13704 static_cast<VkBuffer>( buffer ), 13705 static_cast<VkDeviceSize>( offset ), 13706 static_cast<VkIndexType>( indexType ) ); 13707 } 13708 bindVertexBuffers(uint32_t firstBinding,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets) const13709 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, 13710 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 13711 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const 13712 { 13713 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers && "Function <vkCmdBindVertexBuffers> requires <VK_VERSION_1_0>" ); 13714 # ifdef VULKAN_HPP_NO_EXCEPTIONS 13715 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); 13716 # else 13717 if ( buffers.size() != offsets.size() ) 13718 { 13719 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); 13720 } 13721 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 13722 13723 getDispatcher()->vkCmdBindVertexBuffers( static_cast<VkCommandBuffer>( m_commandBuffer ), 13724 firstBinding, 13725 buffers.size(), 13726 reinterpret_cast<const VkBuffer *>( buffers.data() ), 13727 reinterpret_cast<const VkDeviceSize *>( offsets.data() ) ); 13728 } 13729 13730 VULKAN_HPP_INLINE void draw(uint32_t vertexCount,uint32_t instanceCount,uint32_t firstVertex,uint32_t firstInstance) const13731 CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT 13732 { 13733 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDraw && "Function <vkCmdDraw> requires <VK_VERSION_1_0>" ); 13734 13735 getDispatcher()->vkCmdDraw( static_cast<VkCommandBuffer>( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance ); 13736 } 13737 drawIndexed(uint32_t indexCount,uint32_t instanceCount,uint32_t firstIndex,int32_t vertexOffset,uint32_t firstInstance) const13738 VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( 13739 uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT 13740 { 13741 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexed && "Function <vkCmdDrawIndexed> requires <VK_VERSION_1_0>" ); 13742 13743 getDispatcher()->vkCmdDrawIndexed( static_cast<VkCommandBuffer>( m_commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); 13744 } 13745 drawIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,uint32_t drawCount,uint32_t stride) const13746 VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 13747 VULKAN_HPP_NAMESPACE::DeviceSize offset, 13748 uint32_t drawCount, 13749 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 13750 { 13751 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirect && "Function <vkCmdDrawIndirect> requires <VK_VERSION_1_0>" ); 13752 13753 getDispatcher()->vkCmdDrawIndirect( 13754 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); 13755 } 13756 drawIndexedIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,uint32_t drawCount,uint32_t stride) const13757 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 13758 VULKAN_HPP_NAMESPACE::DeviceSize offset, 13759 uint32_t drawCount, 13760 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 13761 { 13762 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexedIndirect && "Function <vkCmdDrawIndexedIndirect> requires <VK_VERSION_1_0>" ); 13763 13764 getDispatcher()->vkCmdDrawIndexedIndirect( 13765 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); 13766 } 13767 dispatch(uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const13768 VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 13769 { 13770 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatch && "Function <vkCmdDispatch> requires <VK_VERSION_1_0>" ); 13771 13772 getDispatcher()->vkCmdDispatch( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); 13773 } 13774 dispatchIndirect(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset) const13775 VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, 13776 VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT 13777 { 13778 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchIndirect && "Function <vkCmdDispatchIndirect> requires <VK_VERSION_1_0>" ); 13779 13780 getDispatcher()->vkCmdDispatchIndirect( 13781 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) ); 13782 } 13783 13784 VULKAN_HPP_INLINE void copyBuffer(VULKAN_HPP_NAMESPACE::Buffer srcBuffer,VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions) const13785 CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, 13786 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 13787 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT 13788 { 13789 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer && "Function <vkCmdCopyBuffer> requires <VK_VERSION_1_0>" ); 13790 13791 getDispatcher()->vkCmdCopyBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 13792 static_cast<VkBuffer>( srcBuffer ), 13793 static_cast<VkBuffer>( dstBuffer ), 13794 regions.size(), 13795 reinterpret_cast<const VkBufferCopy *>( regions.data() ) ); 13796 } 13797 13798 VULKAN_HPP_INLINE void copyImage(VULKAN_HPP_NAMESPACE::Image srcImage,VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,VULKAN_HPP_NAMESPACE::Image dstImage,VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions) const13799 CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, 13800 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 13801 VULKAN_HPP_NAMESPACE::Image dstImage, 13802 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 13803 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT 13804 { 13805 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage && "Function <vkCmdCopyImage> requires <VK_VERSION_1_0>" ); 13806 13807 getDispatcher()->vkCmdCopyImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 13808 static_cast<VkImage>( srcImage ), 13809 static_cast<VkImageLayout>( srcImageLayout ), 13810 static_cast<VkImage>( dstImage ), 13811 static_cast<VkImageLayout>( dstImageLayout ), 13812 regions.size(), 13813 reinterpret_cast<const VkImageCopy *>( regions.data() ) ); 13814 } 13815 blitImage(VULKAN_HPP_NAMESPACE::Image srcImage,VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,VULKAN_HPP_NAMESPACE::Image dstImage,VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,VULKAN_HPP_NAMESPACE::Filter filter) const13816 VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, 13817 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 13818 VULKAN_HPP_NAMESPACE::Image dstImage, 13819 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 13820 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions, 13821 VULKAN_HPP_NAMESPACE::Filter filter ) const VULKAN_HPP_NOEXCEPT 13822 { 13823 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage && "Function <vkCmdBlitImage> requires <VK_VERSION_1_0>" ); 13824 13825 getDispatcher()->vkCmdBlitImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 13826 static_cast<VkImage>( srcImage ), 13827 static_cast<VkImageLayout>( srcImageLayout ), 13828 static_cast<VkImage>( dstImage ), 13829 static_cast<VkImageLayout>( dstImageLayout ), 13830 regions.size(), 13831 reinterpret_cast<const VkImageBlit *>( regions.data() ), 13832 static_cast<VkFilter>( filter ) ); 13833 } 13834 copyBufferToImage(VULKAN_HPP_NAMESPACE::Buffer srcBuffer,VULKAN_HPP_NAMESPACE::Image dstImage,VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions) const13835 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( 13836 VULKAN_HPP_NAMESPACE::Buffer srcBuffer, 13837 VULKAN_HPP_NAMESPACE::Image dstImage, 13838 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 13839 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT 13840 { 13841 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage && "Function <vkCmdCopyBufferToImage> requires <VK_VERSION_1_0>" ); 13842 13843 getDispatcher()->vkCmdCopyBufferToImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 13844 static_cast<VkBuffer>( srcBuffer ), 13845 static_cast<VkImage>( dstImage ), 13846 static_cast<VkImageLayout>( dstImageLayout ), 13847 regions.size(), 13848 reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) ); 13849 } 13850 copyImageToBuffer(VULKAN_HPP_NAMESPACE::Image srcImage,VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions) const13851 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( 13852 VULKAN_HPP_NAMESPACE::Image srcImage, 13853 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 13854 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 13855 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT 13856 { 13857 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer && "Function <vkCmdCopyImageToBuffer> requires <VK_VERSION_1_0>" ); 13858 13859 getDispatcher()->vkCmdCopyImageToBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 13860 static_cast<VkImage>( srcImage ), 13861 static_cast<VkImageLayout>( srcImageLayout ), 13862 static_cast<VkBuffer>( dstBuffer ), 13863 regions.size(), 13864 reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) ); 13865 } 13866 13867 template <typename DataType> updateBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data) const13868 VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 13869 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 13870 VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data ) const VULKAN_HPP_NOEXCEPT 13871 { 13872 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdUpdateBuffer && "Function <vkCmdUpdateBuffer> requires <VK_VERSION_1_0>" ); 13873 13874 getDispatcher()->vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 13875 static_cast<VkBuffer>( dstBuffer ), 13876 static_cast<VkDeviceSize>( dstOffset ), 13877 data.size() * sizeof( DataType ), 13878 reinterpret_cast<const void *>( data.data() ) ); 13879 } 13880 fillBuffer(VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,VULKAN_HPP_NAMESPACE::DeviceSize size,uint32_t data) const13881 VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 13882 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 13883 VULKAN_HPP_NAMESPACE::DeviceSize size, 13884 uint32_t data ) const VULKAN_HPP_NOEXCEPT 13885 { 13886 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdFillBuffer && "Function <vkCmdFillBuffer> requires <VK_VERSION_1_0>" ); 13887 13888 getDispatcher()->vkCmdFillBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), 13889 static_cast<VkBuffer>( dstBuffer ), 13890 static_cast<VkDeviceSize>( dstOffset ), 13891 static_cast<VkDeviceSize>( size ), 13892 data ); 13893 } 13894 clearColorImage(VULKAN_HPP_NAMESPACE::Image image,VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,const VULKAN_HPP_NAMESPACE::ClearColorValue & color,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges) const13895 VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( 13896 VULKAN_HPP_NAMESPACE::Image image, 13897 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, 13898 const VULKAN_HPP_NAMESPACE::ClearColorValue & color, 13899 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT 13900 { 13901 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearColorImage && "Function <vkCmdClearColorImage> requires <VK_VERSION_1_0>" ); 13902 13903 getDispatcher()->vkCmdClearColorImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 13904 static_cast<VkImage>( image ), 13905 static_cast<VkImageLayout>( imageLayout ), 13906 reinterpret_cast<const VkClearColorValue *>( &color ), 13907 ranges.size(), 13908 reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) ); 13909 } 13910 clearDepthStencilImage(VULKAN_HPP_NAMESPACE::Image image,VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges) const13911 VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( 13912 VULKAN_HPP_NAMESPACE::Image image, 13913 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout, 13914 const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil, 13915 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT 13916 { 13917 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearDepthStencilImage && "Function <vkCmdClearDepthStencilImage> requires <VK_VERSION_1_0>" ); 13918 13919 getDispatcher()->vkCmdClearDepthStencilImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 13920 static_cast<VkImage>( image ), 13921 static_cast<VkImageLayout>( imageLayout ), 13922 reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ), 13923 ranges.size(), 13924 reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) ); 13925 } 13926 13927 VULKAN_HPP_INLINE void clearAttachments(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects) const13928 CommandBuffer::clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments, 13929 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects ) const VULKAN_HPP_NOEXCEPT 13930 { 13931 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearAttachments && "Function <vkCmdClearAttachments> requires <VK_VERSION_1_0>" ); 13932 13933 getDispatcher()->vkCmdClearAttachments( static_cast<VkCommandBuffer>( m_commandBuffer ), 13934 attachments.size(), 13935 reinterpret_cast<const VkClearAttachment *>( attachments.data() ), 13936 rects.size(), 13937 reinterpret_cast<const VkClearRect *>( rects.data() ) ); 13938 } 13939 13940 VULKAN_HPP_INLINE void resolveImage(VULKAN_HPP_NAMESPACE::Image srcImage,VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,VULKAN_HPP_NAMESPACE::Image dstImage,VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions) const13941 CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, 13942 VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout, 13943 VULKAN_HPP_NAMESPACE::Image dstImage, 13944 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 13945 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT 13946 { 13947 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage && "Function <vkCmdResolveImage> requires <VK_VERSION_1_0>" ); 13948 13949 getDispatcher()->vkCmdResolveImage( static_cast<VkCommandBuffer>( m_commandBuffer ), 13950 static_cast<VkImage>( srcImage ), 13951 static_cast<VkImageLayout>( srcImageLayout ), 13952 static_cast<VkImage>( dstImage ), 13953 static_cast<VkImageLayout>( dstImageLayout ), 13954 regions.size(), 13955 reinterpret_cast<const VkImageResolve *>( regions.data() ) ); 13956 } 13957 setEvent(VULKAN_HPP_NAMESPACE::Event event,VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask) const13958 VULKAN_HPP_INLINE void CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event event, 13959 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT 13960 { 13961 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent && "Function <vkCmdSetEvent> requires <VK_VERSION_1_0>" ); 13962 13963 getDispatcher()->vkCmdSetEvent( 13964 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) ); 13965 } 13966 resetEvent(VULKAN_HPP_NAMESPACE::Event event,VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask) const13967 VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event, 13968 VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT 13969 { 13970 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent && "Function <vkCmdResetEvent> requires <VK_VERSION_1_0>" ); 13971 13972 getDispatcher()->vkCmdResetEvent( 13973 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) ); 13974 } 13975 waitEvents(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers) const13976 VULKAN_HPP_INLINE void CommandBuffer::waitEvents( 13977 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 13978 VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, 13979 VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, 13980 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, 13981 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, 13982 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT 13983 { 13984 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents && "Function <vkCmdWaitEvents> requires <VK_VERSION_1_0>" ); 13985 13986 getDispatcher()->vkCmdWaitEvents( static_cast<VkCommandBuffer>( m_commandBuffer ), 13987 events.size(), 13988 reinterpret_cast<const VkEvent *>( events.data() ), 13989 static_cast<VkPipelineStageFlags>( srcStageMask ), 13990 static_cast<VkPipelineStageFlags>( dstStageMask ), 13991 memoryBarriers.size(), 13992 reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ), 13993 bufferMemoryBarriers.size(), 13994 reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ), 13995 imageMemoryBarriers.size(), 13996 reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) ); 13997 } 13998 pipelineBarrier(VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask,VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers) const13999 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( 14000 VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask, 14001 VULKAN_HPP_NAMESPACE::PipelineStageFlags dstStageMask, 14002 VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags, 14003 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers, 14004 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers, 14005 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT 14006 { 14007 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier && "Function <vkCmdPipelineBarrier> requires <VK_VERSION_1_0>" ); 14008 14009 getDispatcher()->vkCmdPipelineBarrier( static_cast<VkCommandBuffer>( m_commandBuffer ), 14010 static_cast<VkPipelineStageFlags>( srcStageMask ), 14011 static_cast<VkPipelineStageFlags>( dstStageMask ), 14012 static_cast<VkDependencyFlags>( dependencyFlags ), 14013 memoryBarriers.size(), 14014 reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ), 14015 bufferMemoryBarriers.size(), 14016 reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ), 14017 imageMemoryBarriers.size(), 14018 reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) ); 14019 } 14020 beginQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query,VULKAN_HPP_NAMESPACE::QueryControlFlags flags) const14021 VULKAN_HPP_INLINE void CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 14022 uint32_t query, 14023 VULKAN_HPP_NAMESPACE::QueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT 14024 { 14025 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQuery && "Function <vkCmdBeginQuery> requires <VK_VERSION_1_0>" ); 14026 14027 getDispatcher()->vkCmdBeginQuery( 14028 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) ); 14029 } 14030 endQuery(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query) const14031 VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT 14032 { 14033 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQuery && "Function <vkCmdEndQuery> requires <VK_VERSION_1_0>" ); 14034 14035 getDispatcher()->vkCmdEndQuery( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query ); 14036 } 14037 14038 VULKAN_HPP_INLINE void resetQueryPool(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const14039 CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT 14040 { 14041 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetQueryPool && "Function <vkCmdResetQueryPool> requires <VK_VERSION_1_0>" ); 14042 14043 getDispatcher()->vkCmdResetQueryPool( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount ); 14044 } 14045 writeTimestamp(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query) const14046 VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, 14047 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 14048 uint32_t query ) const VULKAN_HPP_NOEXCEPT 14049 { 14050 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp && "Function <vkCmdWriteTimestamp> requires <VK_VERSION_1_0>" ); 14051 14052 getDispatcher()->vkCmdWriteTimestamp( 14053 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query ); 14054 } 14055 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) const14056 VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 14057 uint32_t firstQuery, 14058 uint32_t queryCount, 14059 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 14060 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 14061 VULKAN_HPP_NAMESPACE::DeviceSize stride, 14062 VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT 14063 { 14064 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyQueryPoolResults && "Function <vkCmdCopyQueryPoolResults> requires <VK_VERSION_1_0>" ); 14065 14066 getDispatcher()->vkCmdCopyQueryPoolResults( static_cast<VkCommandBuffer>( m_commandBuffer ), 14067 static_cast<VkQueryPool>( queryPool ), 14068 firstQuery, 14069 queryCount, 14070 static_cast<VkBuffer>( dstBuffer ), 14071 static_cast<VkDeviceSize>( dstOffset ), 14072 static_cast<VkDeviceSize>( stride ), 14073 static_cast<VkQueryResultFlags>( flags ) ); 14074 } 14075 14076 template <typename ValuesType> pushConstants(VULKAN_HPP_NAMESPACE::PipelineLayout layout,VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,uint32_t offset,VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values) const14077 VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, 14078 VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags, 14079 uint32_t offset, 14080 VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values ) const VULKAN_HPP_NOEXCEPT 14081 { 14082 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants && "Function <vkCmdPushConstants> requires <VK_VERSION_1_0>" ); 14083 14084 getDispatcher()->vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), 14085 static_cast<VkPipelineLayout>( layout ), 14086 static_cast<VkShaderStageFlags>( stageFlags ), 14087 offset, 14088 values.size() * sizeof( ValuesType ), 14089 reinterpret_cast<const void *>( values.data() ) ); 14090 } 14091 beginRenderPass(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,VULKAN_HPP_NAMESPACE::SubpassContents contents) const14092 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 14093 VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT 14094 { 14095 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass && "Function <vkCmdBeginRenderPass> requires <VK_VERSION_1_0>" ); 14096 14097 getDispatcher()->vkCmdBeginRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ), 14098 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), 14099 static_cast<VkSubpassContents>( contents ) ); 14100 } 14101 nextSubpass(VULKAN_HPP_NAMESPACE::SubpassContents contents) const14102 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT 14103 { 14104 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass && "Function <vkCmdNextSubpass> requires <VK_VERSION_1_0>" ); 14105 14106 getDispatcher()->vkCmdNextSubpass( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkSubpassContents>( contents ) ); 14107 } 14108 endRenderPass() const14109 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const VULKAN_HPP_NOEXCEPT 14110 { 14111 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass && "Function <vkCmdEndRenderPass> requires <VK_VERSION_1_0>" ); 14112 14113 getDispatcher()->vkCmdEndRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 14114 } 14115 executeCommands(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers) const14116 VULKAN_HPP_INLINE void CommandBuffer::executeCommands( 14117 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const VULKAN_HPP_NOEXCEPT 14118 { 14119 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdExecuteCommands && "Function <vkCmdExecuteCommands> requires <VK_VERSION_1_0>" ); 14120 14121 getDispatcher()->vkCmdExecuteCommands( 14122 static_cast<VkCommandBuffer>( m_commandBuffer ), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) ); 14123 } 14124 14125 //=== VK_VERSION_1_1 === 14126 enumerateInstanceVersion() const14127 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t Context::enumerateInstanceVersion() const 14128 { 14129 VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceVersion && "Function <vkEnumerateInstanceVersion> requires <VK_VERSION_1_1>" ); 14130 14131 uint32_t apiVersion; 14132 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceVersion( &apiVersion ) ); 14133 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceVersion" ); 14134 14135 return apiVersion; 14136 } 14137 14138 VULKAN_HPP_INLINE void bindBufferMemory2(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos) const14139 Device::bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const 14140 { 14141 VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2 && "Function <vkBindBufferMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" ); 14142 14143 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindBufferMemory2( 14144 static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) ); 14145 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" ); 14146 } 14147 bindImageMemory2(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos) const14148 VULKAN_HPP_INLINE void Device::bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const 14149 { 14150 VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2 && "Function <vkBindImageMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" ); 14151 14152 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindImageMemory2( 14153 static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) ); 14154 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" ); 14155 } 14156 14157 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex) const14158 Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT 14159 { 14160 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures && 14161 "Function <vkGetDeviceGroupPeerMemoryFeatures> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" ); 14162 14163 VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; 14164 getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures( static_cast<VkDevice>( m_device ), 14165 heapIndex, 14166 localDeviceIndex, 14167 remoteDeviceIndex, 14168 reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) ); 14169 14170 return peerMemoryFeatures; 14171 } 14172 setDeviceMask(uint32_t deviceMask) const14173 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT 14174 { 14175 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMask && "Function <vkCmdSetDeviceMask> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" ); 14176 14177 getDispatcher()->vkCmdSetDeviceMask( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask ); 14178 } 14179 dispatchBase(uint32_t baseGroupX,uint32_t baseGroupY,uint32_t baseGroupZ,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const14180 VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, 14181 uint32_t baseGroupY, 14182 uint32_t baseGroupZ, 14183 uint32_t groupCountX, 14184 uint32_t groupCountY, 14185 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 14186 { 14187 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBase && "Function <vkCmdDispatchBase> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" ); 14188 14189 getDispatcher()->vkCmdDispatchBase( 14190 static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); 14191 } 14192 enumeratePhysicalDeviceGroups() const14193 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> Instance::enumeratePhysicalDeviceGroups() const 14194 { 14195 VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceGroups && 14196 "Function <vkEnumeratePhysicalDeviceGroups> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" ); 14197 14198 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties; 14199 uint32_t physicalDeviceGroupCount; 14200 VULKAN_HPP_NAMESPACE::Result result; 14201 do 14202 { 14203 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14204 getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) ); 14205 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount ) 14206 { 14207 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); 14208 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14209 getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast<VkInstance>( m_instance ), 14210 &physicalDeviceGroupCount, 14211 reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); 14212 } 14213 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 14214 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); 14215 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); 14216 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) 14217 { 14218 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); 14219 } 14220 return physicalDeviceGroupProperties; 14221 } 14222 14223 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info) const14224 Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 14225 { 14226 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2 && 14227 "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 14228 14229 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 14230 getDispatcher()->vkGetImageMemoryRequirements2( static_cast<VkDevice>( m_device ), 14231 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), 14232 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 14233 14234 return memoryRequirements; 14235 } 14236 14237 template <typename X, typename Y, typename... Z> 14238 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info) const14239 Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 14240 { 14241 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2 && 14242 "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 14243 14244 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 14245 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 14246 getDispatcher()->vkGetImageMemoryRequirements2( static_cast<VkDevice>( m_device ), 14247 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), 14248 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 14249 14250 return structureChain; 14251 } 14252 14253 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info) const14254 Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 14255 { 14256 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2 && 14257 "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 14258 14259 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 14260 getDispatcher()->vkGetBufferMemoryRequirements2( static_cast<VkDevice>( m_device ), 14261 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), 14262 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 14263 14264 return memoryRequirements; 14265 } 14266 14267 template <typename X, typename Y, typename... Z> 14268 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirements2(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info) const14269 Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 14270 { 14271 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2 && 14272 "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 14273 14274 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 14275 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 14276 getDispatcher()->vkGetBufferMemoryRequirements2( static_cast<VkDevice>( m_device ), 14277 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), 14278 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 14279 14280 return structureChain; 14281 } 14282 14283 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> getImageSparseMemoryRequirements2(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info) const14284 Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const 14285 { 14286 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements2 && 14287 "Function <vkGetImageSparseMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 14288 14289 std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements; 14290 uint32_t sparseMemoryRequirementCount; 14291 getDispatcher()->vkGetImageSparseMemoryRequirements2( 14292 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr ); 14293 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 14294 getDispatcher()->vkGetImageSparseMemoryRequirements2( static_cast<VkDevice>( m_device ), 14295 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), 14296 &sparseMemoryRequirementCount, 14297 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); 14298 14299 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); 14300 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) 14301 { 14302 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 14303 } 14304 return sparseMemoryRequirements; 14305 } 14306 getFeatures2() const14307 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT 14308 { 14309 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2 && 14310 "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14311 14312 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; 14313 getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14314 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); 14315 14316 return features; 14317 } 14318 14319 template <typename X, typename Y, typename... Z> getFeatures2() const14320 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT 14321 { 14322 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2 && 14323 "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14324 14325 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 14326 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); 14327 getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14328 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); 14329 14330 return structureChain; 14331 } 14332 getProperties2() const14333 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT 14334 { 14335 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2 && 14336 "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14337 14338 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; 14339 getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14340 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); 14341 14342 return properties; 14343 } 14344 14345 template <typename X, typename Y, typename... Z> getProperties2() const14346 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT 14347 { 14348 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2 && 14349 "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14350 14351 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 14352 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); 14353 getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14354 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); 14355 14356 return structureChain; 14357 } 14358 14359 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format) const14360 PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 14361 { 14362 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2 && 14363 "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14364 14365 VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; 14366 getDispatcher()->vkGetPhysicalDeviceFormatProperties2( 14367 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); 14368 14369 return formatProperties; 14370 } 14371 14372 template <typename X, typename Y, typename... Z> 14373 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFormatProperties2(VULKAN_HPP_NAMESPACE::Format format) const14374 PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 14375 { 14376 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2 && 14377 "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14378 14379 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 14380 VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); 14381 getDispatcher()->vkGetPhysicalDeviceFormatProperties2( 14382 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); 14383 14384 return structureChain; 14385 } 14386 14387 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2 getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo) const14388 PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const 14389 { 14390 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2 && 14391 "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14392 14393 VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; 14394 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14395 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14396 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), 14397 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); 14398 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); 14399 14400 return imageFormatProperties; 14401 } 14402 14403 template <typename X, typename Y, typename... Z> 14404 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo) const14405 PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const 14406 { 14407 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2 && 14408 "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14409 14410 StructureChain<X, Y, Z...> structureChain; 14411 VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); 14412 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14413 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14414 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), 14415 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); 14416 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); 14417 14418 return structureChain; 14419 } 14420 getQueueFamilyProperties2() const14421 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> PhysicalDevice::getQueueFamilyProperties2() const 14422 { 14423 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2 && 14424 "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14425 14426 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties; 14427 uint32_t queueFamilyPropertyCount; 14428 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 14429 queueFamilyProperties.resize( queueFamilyPropertyCount ); 14430 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14431 &queueFamilyPropertyCount, 14432 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); 14433 14434 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); 14435 if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) 14436 { 14437 queueFamilyProperties.resize( queueFamilyPropertyCount ); 14438 } 14439 return queueFamilyProperties; 14440 } 14441 14442 template <typename StructureChain> getQueueFamilyProperties2() const14443 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2() const 14444 { 14445 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2 && 14446 "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14447 14448 std::vector<StructureChain> structureChains; 14449 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties; 14450 uint32_t queueFamilyPropertyCount; 14451 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 14452 structureChains.resize( queueFamilyPropertyCount ); 14453 queueFamilyProperties.resize( queueFamilyPropertyCount ); 14454 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) 14455 { 14456 queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; 14457 } 14458 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14459 &queueFamilyPropertyCount, 14460 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); 14461 14462 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); 14463 if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) 14464 { 14465 structureChains.resize( queueFamilyPropertyCount ); 14466 } 14467 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) 14468 { 14469 structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; 14470 } 14471 return structureChains; 14472 } 14473 14474 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2() const14475 PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT 14476 { 14477 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2 && 14478 "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14479 14480 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; 14481 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14482 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); 14483 14484 return memoryProperties; 14485 } 14486 14487 template <typename X, typename Y, typename... Z> getMemoryProperties2() const14488 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT 14489 { 14490 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2 && 14491 "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14492 14493 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 14494 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = 14495 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); 14496 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14497 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); 14498 14499 return structureChain; 14500 } 14501 14502 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> getSparseImageFormatProperties2(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo) const14503 PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const 14504 { 14505 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2 && 14506 "Function <vkGetPhysicalDeviceSparseImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 14507 14508 std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties; 14509 uint32_t propertyCount; 14510 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14511 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), 14512 &propertyCount, 14513 nullptr ); 14514 properties.resize( propertyCount ); 14515 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14516 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), 14517 &propertyCount, 14518 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); 14519 14520 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 14521 if ( propertyCount < properties.size() ) 14522 { 14523 properties.resize( propertyCount ); 14524 } 14525 return properties; 14526 } 14527 trim(VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags) const14528 VULKAN_HPP_INLINE void CommandPool::trim( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT 14529 { 14530 VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPool && "Function <vkTrimCommandPool> requires <VK_KHR_maintenance1> or <VK_VERSION_1_1>" ); 14531 14532 getDispatcher()->vkTrimCommandPool( 14533 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) ); 14534 } 14535 14536 VULKAN_HPP_NODISCARD 14537 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue>::Type getQueue2(VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo) const14538 Device::getQueue2( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 14539 { 14540 VULKAN_HPP_NAMESPACE::Queue queue; 14541 getDispatcher()->vkGetDeviceQueue2( 14542 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &queue ) ); 14543 14544 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue( *this, *reinterpret_cast<VkQueue *>( &queue ) ); 14545 } 14546 14547 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 14548 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion>::Type createSamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const14549 Device::createSamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 14550 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 14551 VULKAN_HPP_RAII_CREATE_NOEXCEPT 14552 { 14553 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; 14554 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSamplerYcbcrConversion( 14555 static_cast<VkDevice>( m_device ), 14556 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ), 14557 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 14558 reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) ); 14559 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14560 { 14561 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 14562 return VULKAN_HPP_UNEXPECTED( result ); 14563 # else 14564 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSamplerYcbcrConversion" ); 14565 # endif 14566 } 14567 14568 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion( 14569 *this, *reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ), allocator ); 14570 } 14571 14572 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 14573 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate>::Type createDescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const14574 Device::createDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 14575 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 14576 VULKAN_HPP_RAII_CREATE_NOEXCEPT 14577 { 14578 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; 14579 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDescriptorUpdateTemplate( 14580 static_cast<VkDevice>( m_device ), 14581 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ), 14582 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 14583 reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) ); 14584 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14585 { 14586 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 14587 return VULKAN_HPP_UNEXPECTED( result ); 14588 # else 14589 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDescriptorUpdateTemplate" ); 14590 # endif 14591 } 14592 14593 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( 14594 *this, *reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ), allocator ); 14595 } 14596 14597 template <typename DataType> updateWithTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,DataType const & data) const14598 VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 14599 DataType const & data ) const VULKAN_HPP_NOEXCEPT 14600 { 14601 VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSetWithTemplate && 14602 "Function <vkUpdateDescriptorSetWithTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); 14603 14604 getDispatcher()->vkUpdateDescriptorSetWithTemplate( static_cast<VkDevice>( m_device ), 14605 static_cast<VkDescriptorSet>( m_descriptorSet ), 14606 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), 14607 reinterpret_cast<const void *>( &data ) ); 14608 } 14609 14610 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo) const14611 PhysicalDevice::getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT 14612 { 14613 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties && 14614 "Function <vkGetPhysicalDeviceExternalBufferProperties> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" ); 14615 14616 VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; 14617 getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14618 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ), 14619 reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) ); 14620 14621 return externalBufferProperties; 14622 } 14623 14624 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo) const14625 PhysicalDevice::getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT 14626 { 14627 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties && 14628 "Function <vkGetPhysicalDeviceExternalFenceProperties> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" ); 14629 14630 VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; 14631 getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), 14632 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ), 14633 reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) ); 14634 14635 return externalFenceProperties; 14636 } 14637 getExternalSemaphoreProperties(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo) const14638 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( 14639 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT 14640 { 14641 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties && 14642 "Function <vkGetPhysicalDeviceExternalSemaphoreProperties> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" ); 14643 14644 VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; 14645 getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties( 14646 static_cast<VkPhysicalDevice>( m_physicalDevice ), 14647 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ), 14648 reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) ); 14649 14650 return externalSemaphoreProperties; 14651 } 14652 14653 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo) const14654 Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 14655 { 14656 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupport && 14657 "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" ); 14658 14659 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; 14660 getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast<VkDevice>( m_device ), 14661 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 14662 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); 14663 14664 return support; 14665 } 14666 14667 template <typename X, typename Y, typename... Z> 14668 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo) const14669 Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 14670 { 14671 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupport && 14672 "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" ); 14673 14674 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 14675 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); 14676 getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast<VkDevice>( m_device ), 14677 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 14678 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); 14679 14680 return structureChain; 14681 } 14682 14683 //=== VK_VERSION_1_2 === 14684 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) const14685 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, 14686 VULKAN_HPP_NAMESPACE::DeviceSize offset, 14687 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 14688 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 14689 uint32_t maxDrawCount, 14690 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 14691 { 14692 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCount && 14693 "Function <vkCmdDrawIndirectCount> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" ); 14694 14695 getDispatcher()->vkCmdDrawIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ), 14696 static_cast<VkBuffer>( buffer ), 14697 static_cast<VkDeviceSize>( offset ), 14698 static_cast<VkBuffer>( countBuffer ), 14699 static_cast<VkDeviceSize>( countBufferOffset ), 14700 maxDrawCount, 14701 stride ); 14702 } 14703 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) const14704 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, 14705 VULKAN_HPP_NAMESPACE::DeviceSize offset, 14706 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 14707 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 14708 uint32_t maxDrawCount, 14709 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 14710 { 14711 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexedIndirectCount && 14712 "Function <vkCmdDrawIndexedIndirectCount> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" ); 14713 14714 getDispatcher()->vkCmdDrawIndexedIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ), 14715 static_cast<VkBuffer>( buffer ), 14716 static_cast<VkDeviceSize>( offset ), 14717 static_cast<VkBuffer>( countBuffer ), 14718 static_cast<VkDeviceSize>( countBufferOffset ), 14719 maxDrawCount, 14720 stride ); 14721 } 14722 14723 VULKAN_HPP_NODISCARD 14724 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type createRenderPass2(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const14725 Device::createRenderPass2( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 14726 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 14727 VULKAN_HPP_RAII_CREATE_NOEXCEPT 14728 { 14729 VULKAN_HPP_NAMESPACE::RenderPass renderPass; 14730 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRenderPass2( 14731 static_cast<VkDevice>( m_device ), 14732 reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ), 14733 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 14734 reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); 14735 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14736 { 14737 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 14738 return VULKAN_HPP_UNEXPECTED( result ); 14739 # else 14740 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRenderPass2" ); 14741 # endif 14742 } 14743 14744 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, *reinterpret_cast<VkRenderPass *>( &renderPass ), allocator ); 14745 } 14746 beginRenderPass2(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo) const14747 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 14748 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 14749 { 14750 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2 && 14751 "Function <vkCmdBeginRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); 14752 14753 getDispatcher()->vkCmdBeginRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ), 14754 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), 14755 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) ); 14756 } 14757 nextSubpass2(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo) const14758 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, 14759 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 14760 { 14761 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2 && "Function <vkCmdNextSubpass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); 14762 14763 getDispatcher()->vkCmdNextSubpass2( static_cast<VkCommandBuffer>( m_commandBuffer ), 14764 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), 14765 reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); 14766 } 14767 endRenderPass2(const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo) const14768 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 14769 { 14770 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2 && "Function <vkCmdEndRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); 14771 14772 getDispatcher()->vkCmdEndRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); 14773 } 14774 reset(uint32_t firstQuery,uint32_t queryCount) const14775 VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT 14776 { 14777 VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPool && "Function <vkResetQueryPool> requires <VK_EXT_host_query_reset> or <VK_VERSION_1_2>" ); 14778 14779 getDispatcher()->vkResetQueryPool( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount ); 14780 } 14781 getCounterValue() const14782 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValue() const 14783 { 14784 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreCounterValue && 14785 "Function <vkGetSemaphoreCounterValue> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); 14786 14787 uint64_t value; 14788 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14789 getDispatcher()->vkGetSemaphoreCounterValue( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) ); 14790 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" ); 14791 14792 return value; 14793 } 14794 waitSemaphores(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,uint64_t timeout) const14795 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, 14796 uint64_t timeout ) const 14797 { 14798 VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphores && "Function <vkWaitSemaphores> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); 14799 14800 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14801 getDispatcher()->vkWaitSemaphores( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) ); 14802 VULKAN_HPP_NAMESPACE::detail::resultCheck( 14803 result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); 14804 14805 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 14806 } 14807 signalSemaphore(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo) const14808 VULKAN_HPP_INLINE void Device::signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const 14809 { 14810 VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphore && "Function <vkSignalSemaphore> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); 14811 14812 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14813 getDispatcher()->vkSignalSemaphore( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) ); 14814 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" ); 14815 } 14816 14817 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const14818 Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 14819 { 14820 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferDeviceAddress && 14821 "Function <vkGetBufferDeviceAddress> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); 14822 14823 VkDeviceAddress result = 14824 getDispatcher()->vkGetBufferDeviceAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); 14825 14826 return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); 14827 } 14828 14829 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t getBufferOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const14830 Device::getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 14831 { 14832 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferOpaqueCaptureAddress && 14833 "Function <vkGetBufferOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); 14834 14835 uint64_t result = 14836 getDispatcher()->vkGetBufferOpaqueCaptureAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); 14837 14838 return result; 14839 } 14840 14841 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t getMemoryOpaqueCaptureAddress(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info) const14842 Device::getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 14843 { 14844 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress && 14845 "Function <vkGetDeviceMemoryOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); 14846 14847 uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress( static_cast<VkDevice>( m_device ), 14848 reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) ); 14849 14850 return result; 14851 } 14852 14853 //=== VK_VERSION_1_3 === 14854 getToolProperties() const14855 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> PhysicalDevice::getToolProperties() const 14856 { 14857 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceToolProperties && 14858 "Function <vkGetPhysicalDeviceToolProperties> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" ); 14859 14860 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties; 14861 uint32_t toolCount; 14862 VULKAN_HPP_NAMESPACE::Result result; 14863 do 14864 { 14865 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 14866 getDispatcher()->vkGetPhysicalDeviceToolProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, nullptr ) ); 14867 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount ) 14868 { 14869 toolProperties.resize( toolCount ); 14870 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolProperties( 14871 static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) ); 14872 } 14873 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 14874 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" ); 14875 VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); 14876 if ( toolCount < toolProperties.size() ) 14877 { 14878 toolProperties.resize( toolCount ); 14879 } 14880 return toolProperties; 14881 } 14882 14883 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 14884 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot>::Type createPrivateDataSlot(VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const14885 Device::createPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo, 14886 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 14887 VULKAN_HPP_RAII_CREATE_NOEXCEPT 14888 { 14889 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; 14890 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePrivateDataSlot( 14891 static_cast<VkDevice>( m_device ), 14892 reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ), 14893 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 14894 reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) ); 14895 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 14896 { 14897 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 14898 return VULKAN_HPP_UNEXPECTED( result ); 14899 # else 14900 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPrivateDataSlot" ); 14901 # endif 14902 } 14903 14904 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot( *this, *reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ), allocator ); 14905 } 14906 setPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType_,uint64_t objectHandle,VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,uint64_t data) const14907 VULKAN_HPP_INLINE void Device::setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 14908 uint64_t objectHandle, 14909 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, 14910 uint64_t data ) const 14911 { 14912 VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateData && "Function <vkSetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); 14913 14914 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetPrivateData( 14915 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) ); 14916 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData" ); 14917 } 14918 getPrivateData(VULKAN_HPP_NAMESPACE::ObjectType objectType_,uint64_t objectHandle,VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot) const14919 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 14920 uint64_t objectHandle, 14921 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT 14922 { 14923 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateData && "Function <vkGetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); 14924 14925 uint64_t data; 14926 getDispatcher()->vkGetPrivateData( 14927 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data ); 14928 14929 return data; 14930 } 14931 setEvent2(VULKAN_HPP_NAMESPACE::Event event,const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo) const14932 VULKAN_HPP_INLINE void CommandBuffer::setEvent2( VULKAN_HPP_NAMESPACE::Event event, 14933 const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 14934 { 14935 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2 && "Function <vkCmdSetEvent2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 14936 14937 getDispatcher()->vkCmdSetEvent2( 14938 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) ); 14939 } 14940 resetEvent2(VULKAN_HPP_NAMESPACE::Event event,VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask) const14941 VULKAN_HPP_INLINE void CommandBuffer::resetEvent2( VULKAN_HPP_NAMESPACE::Event event, 14942 VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT 14943 { 14944 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2 && "Function <vkCmdResetEvent2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 14945 14946 getDispatcher()->vkCmdResetEvent2( 14947 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) ); 14948 } 14949 14950 VULKAN_HPP_INLINE void waitEvents2(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos) const14951 CommandBuffer::waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 14952 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos ) const 14953 { 14954 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2 && "Function <vkCmdWaitEvents2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 14955 # ifdef VULKAN_HPP_NO_EXCEPTIONS 14956 VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); 14957 # else 14958 if ( events.size() != dependencyInfos.size() ) 14959 { 14960 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()" ); 14961 } 14962 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 14963 14964 getDispatcher()->vkCmdWaitEvents2( static_cast<VkCommandBuffer>( m_commandBuffer ), 14965 events.size(), 14966 reinterpret_cast<const VkEvent *>( events.data() ), 14967 reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) ); 14968 } 14969 pipelineBarrier2(const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo) const14970 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 14971 { 14972 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2 && "Function <vkCmdPipelineBarrier2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 14973 14974 getDispatcher()->vkCmdPipelineBarrier2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) ); 14975 } 14976 writeTimestamp2(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query) const14977 VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, 14978 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 14979 uint32_t query ) const VULKAN_HPP_NOEXCEPT 14980 { 14981 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2 && "Function <vkCmdWriteTimestamp2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 14982 14983 getDispatcher()->vkCmdWriteTimestamp2( 14984 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query ); 14985 } 14986 submit2(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,VULKAN_HPP_NAMESPACE::Fence fence) const14987 VULKAN_HPP_INLINE void Queue::submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, 14988 VULKAN_HPP_NAMESPACE::Fence fence ) const 14989 { 14990 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2 && "Function <vkQueueSubmit2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 14991 14992 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSubmit2( 14993 static_cast<VkQueue>( m_queue ), submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) ); 14994 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2" ); 14995 } 14996 copyBuffer2(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo) const14997 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT 14998 { 14999 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2 && "Function <vkCmdCopyBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 15000 15001 getDispatcher()->vkCmdCopyBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( ©BufferInfo ) ); 15002 } 15003 copyImage2(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo) const15004 VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT 15005 { 15006 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2 && "Function <vkCmdCopyImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 15007 15008 getDispatcher()->vkCmdCopyImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( ©ImageInfo ) ); 15009 } 15010 15011 VULKAN_HPP_INLINE void copyBufferToImage2(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo) const15012 CommandBuffer::copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT 15013 { 15014 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2 && 15015 "Function <vkCmdCopyBufferToImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 15016 15017 getDispatcher()->vkCmdCopyBufferToImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), 15018 reinterpret_cast<const VkCopyBufferToImageInfo2 *>( ©BufferToImageInfo ) ); 15019 } 15020 15021 VULKAN_HPP_INLINE void copyImageToBuffer2(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo) const15022 CommandBuffer::copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT 15023 { 15024 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2 && 15025 "Function <vkCmdCopyImageToBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 15026 15027 getDispatcher()->vkCmdCopyImageToBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ), 15028 reinterpret_cast<const VkCopyImageToBufferInfo2 *>( ©ImageToBufferInfo ) ); 15029 } 15030 blitImage2(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo) const15031 VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT 15032 { 15033 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2 && "Function <vkCmdBlitImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 15034 15035 getDispatcher()->vkCmdBlitImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) ); 15036 } 15037 resolveImage2(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo) const15038 VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT 15039 { 15040 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2 && "Function <vkCmdResolveImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 15041 15042 getDispatcher()->vkCmdResolveImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), 15043 reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) ); 15044 } 15045 beginRendering(const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo) const15046 VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT 15047 { 15048 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRendering && "Function <vkCmdBeginRendering> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" ); 15049 15050 getDispatcher()->vkCmdBeginRendering( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) ); 15051 } 15052 endRendering() const15053 VULKAN_HPP_INLINE void CommandBuffer::endRendering() const VULKAN_HPP_NOEXCEPT 15054 { 15055 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering && "Function <vkCmdEndRendering> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" ); 15056 15057 getDispatcher()->vkCmdEndRendering( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 15058 } 15059 setCullMode(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode) const15060 VULKAN_HPP_INLINE void CommandBuffer::setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT 15061 { 15062 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullMode && 15063 "Function <vkCmdSetCullMode> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15064 15065 getDispatcher()->vkCmdSetCullMode( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) ); 15066 } 15067 setFrontFace(VULKAN_HPP_NAMESPACE::FrontFace frontFace) const15068 VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT 15069 { 15070 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFace && 15071 "Function <vkCmdSetFrontFace> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15072 15073 getDispatcher()->vkCmdSetFrontFace( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) ); 15074 } 15075 setPrimitiveTopology(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology) const15076 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT 15077 { 15078 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopology && 15079 "Function <vkCmdSetPrimitiveTopology> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15080 15081 getDispatcher()->vkCmdSetPrimitiveTopology( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) ); 15082 } 15083 15084 VULKAN_HPP_INLINE void setViewportWithCount(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports) const15085 CommandBuffer::setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT 15086 { 15087 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCount && 15088 "Function <vkCmdSetViewportWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15089 15090 getDispatcher()->vkCmdSetViewportWithCount( 15091 static_cast<VkCommandBuffer>( m_commandBuffer ), viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) ); 15092 } 15093 15094 VULKAN_HPP_INLINE void setScissorWithCount(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors) const15095 CommandBuffer::setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT 15096 { 15097 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCount && 15098 "Function <vkCmdSetScissorWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15099 15100 getDispatcher()->vkCmdSetScissorWithCount( 15101 static_cast<VkCommandBuffer>( m_commandBuffer ), scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) ); 15102 } 15103 bindVertexBuffers2(uint32_t firstBinding,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides) const15104 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding, 15105 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 15106 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 15107 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, 15108 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides ) const 15109 { 15110 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2 && 15111 "Function <vkCmdBindVertexBuffers2> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15112 # ifdef VULKAN_HPP_NO_EXCEPTIONS 15113 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); 15114 VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); 15115 VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); 15116 # else 15117 if ( buffers.size() != offsets.size() ) 15118 { 15119 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" ); 15120 } 15121 if ( !sizes.empty() && buffers.size() != sizes.size() ) 15122 { 15123 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()" ); 15124 } 15125 if ( !strides.empty() && buffers.size() != strides.size() ) 15126 { 15127 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()" ); 15128 } 15129 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 15130 15131 getDispatcher()->vkCmdBindVertexBuffers2( static_cast<VkCommandBuffer>( m_commandBuffer ), 15132 firstBinding, 15133 buffers.size(), 15134 reinterpret_cast<const VkBuffer *>( buffers.data() ), 15135 reinterpret_cast<const VkDeviceSize *>( offsets.data() ), 15136 reinterpret_cast<const VkDeviceSize *>( sizes.data() ), 15137 reinterpret_cast<const VkDeviceSize *>( strides.data() ) ); 15138 } 15139 setDepthTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable) const15140 VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT 15141 { 15142 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnable && 15143 "Function <vkCmdSetDepthTestEnable> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15144 15145 getDispatcher()->vkCmdSetDepthTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) ); 15146 } 15147 setDepthWriteEnable(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable) const15148 VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT 15149 { 15150 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnable && 15151 "Function <vkCmdSetDepthWriteEnable> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15152 15153 getDispatcher()->vkCmdSetDepthWriteEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) ); 15154 } 15155 setDepthCompareOp(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp) const15156 VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT 15157 { 15158 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOp && 15159 "Function <vkCmdSetDepthCompareOp> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15160 15161 getDispatcher()->vkCmdSetDepthCompareOp( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) ); 15162 } 15163 setDepthBoundsTestEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable) const15164 VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT 15165 { 15166 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBoundsTestEnable && 15167 "Function <vkCmdSetDepthBoundsTestEnable> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15168 15169 getDispatcher()->vkCmdSetDepthBoundsTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) ); 15170 } 15171 setStencilTestEnable(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable) const15172 VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT 15173 { 15174 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnable && 15175 "Function <vkCmdSetStencilTestEnable> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15176 15177 getDispatcher()->vkCmdSetStencilTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) ); 15178 } 15179 setStencilOp(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) const15180 VULKAN_HPP_INLINE void CommandBuffer::setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 15181 VULKAN_HPP_NAMESPACE::StencilOp failOp, 15182 VULKAN_HPP_NAMESPACE::StencilOp passOp, 15183 VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, 15184 VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT 15185 { 15186 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOp && 15187 "Function <vkCmdSetStencilOp> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15188 15189 getDispatcher()->vkCmdSetStencilOp( static_cast<VkCommandBuffer>( m_commandBuffer ), 15190 static_cast<VkStencilFaceFlags>( faceMask ), 15191 static_cast<VkStencilOp>( failOp ), 15192 static_cast<VkStencilOp>( passOp ), 15193 static_cast<VkStencilOp>( depthFailOp ), 15194 static_cast<VkCompareOp>( compareOp ) ); 15195 } 15196 setRasterizerDiscardEnable(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable) const15197 VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT 15198 { 15199 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizerDiscardEnable && 15200 "Function <vkCmdSetRasterizerDiscardEnable> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15201 15202 getDispatcher()->vkCmdSetRasterizerDiscardEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) ); 15203 } 15204 setDepthBiasEnable(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable) const15205 VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT 15206 { 15207 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnable && 15208 "Function <vkCmdSetDepthBiasEnable> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15209 15210 getDispatcher()->vkCmdSetDepthBiasEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) ); 15211 } 15212 setPrimitiveRestartEnable(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable) const15213 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT 15214 { 15215 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveRestartEnable && 15216 "Function <vkCmdSetPrimitiveRestartEnable> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 15217 15218 getDispatcher()->vkCmdSetPrimitiveRestartEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) ); 15219 } 15220 15221 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info) const15222 Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT 15223 { 15224 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirements && 15225 "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 15226 15227 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 15228 getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast<VkDevice>( m_device ), 15229 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), 15230 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 15231 15232 return memoryRequirements; 15233 } 15234 15235 template <typename X, typename Y, typename... Z> 15236 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info) const15237 Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT 15238 { 15239 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirements && 15240 "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 15241 15242 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 15243 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 15244 getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast<VkDevice>( m_device ), 15245 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), 15246 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 15247 15248 return structureChain; 15249 } 15250 15251 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info) const15252 Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT 15253 { 15254 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirements && 15255 "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 15256 15257 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 15258 getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast<VkDevice>( m_device ), 15259 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), 15260 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 15261 15262 return memoryRequirements; 15263 } 15264 15265 template <typename X, typename Y, typename... Z> 15266 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info) const15267 Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT 15268 { 15269 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirements && 15270 "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 15271 15272 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 15273 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 15274 getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast<VkDevice>( m_device ), 15275 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), 15276 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 15277 15278 return structureChain; 15279 } 15280 15281 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> getImageSparseMemoryRequirements(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info) const15282 Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const 15283 { 15284 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSparseMemoryRequirements && 15285 "Function <vkGetDeviceImageSparseMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 15286 15287 std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements; 15288 uint32_t sparseMemoryRequirementCount; 15289 getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( 15290 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr ); 15291 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 15292 getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ), 15293 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), 15294 &sparseMemoryRequirementCount, 15295 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); 15296 15297 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); 15298 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) 15299 { 15300 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 15301 } 15302 return sparseMemoryRequirements; 15303 } 15304 15305 //=== VK_VERSION_1_4 === 15306 setLineStipple(uint32_t lineStippleFactor,uint16_t lineStipplePattern) const15307 VULKAN_HPP_INLINE void CommandBuffer::setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT 15308 { 15309 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStipple && 15310 "Function <vkCmdSetLineStipple> requires <VK_EXT_line_rasterization> or <VK_KHR_line_rasterization> or <VK_VERSION_1_4>" ); 15311 15312 getDispatcher()->vkCmdSetLineStipple( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); 15313 } 15314 mapMemory2(const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo) const15315 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * Device::mapMemory2( const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo ) const 15316 { 15317 VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory2 && "Function <vkMapMemory2> requires <VK_KHR_map_memory2> or <VK_VERSION_1_4>" ); 15318 15319 void * pData; 15320 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15321 getDispatcher()->vkMapMemory2( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryMapInfo *>( &memoryMapInfo ), &pData ) ); 15322 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2" ); 15323 15324 return pData; 15325 } 15326 unmapMemory2(const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo) const15327 VULKAN_HPP_INLINE void Device::unmapMemory2( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo ) const 15328 { 15329 VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory2 && "Function <vkUnmapMemory2> requires <VK_KHR_map_memory2> or <VK_VERSION_1_4>" ); 15330 15331 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15332 getDispatcher()->vkUnmapMemory2( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryUnmapInfo *>( &memoryUnmapInfo ) ) ); 15333 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2" ); 15334 } 15335 bindIndexBuffer2(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::DeviceSize size,VULKAN_HPP_NAMESPACE::IndexType indexType) const15336 VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer2( VULKAN_HPP_NAMESPACE::Buffer buffer, 15337 VULKAN_HPP_NAMESPACE::DeviceSize offset, 15338 VULKAN_HPP_NAMESPACE::DeviceSize size, 15339 VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT 15340 { 15341 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer2 && "Function <vkCmdBindIndexBuffer2> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 15342 15343 getDispatcher()->vkCmdBindIndexBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ), 15344 static_cast<VkBuffer>( buffer ), 15345 static_cast<VkDeviceSize>( offset ), 15346 static_cast<VkDeviceSize>( size ), 15347 static_cast<VkIndexType>( indexType ) ); 15348 } 15349 15350 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D getRenderingAreaGranularity(const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo) const15351 Device::getRenderingAreaGranularity( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT 15352 { 15353 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderingAreaGranularity && 15354 "Function <vkGetRenderingAreaGranularity> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 15355 15356 VULKAN_HPP_NAMESPACE::Extent2D granularity; 15357 getDispatcher()->vkGetRenderingAreaGranularity( static_cast<VkDevice>( m_device ), 15358 reinterpret_cast<const VkRenderingAreaInfo *>( &renderingAreaInfo ), 15359 reinterpret_cast<VkExtent2D *>( &granularity ) ); 15360 15361 return granularity; 15362 } 15363 15364 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2 getImageSubresourceLayout(const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info) const15365 Device::getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT 15366 { 15367 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayout && 15368 "Function <vkGetDeviceImageSubresourceLayout> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 15369 15370 VULKAN_HPP_NAMESPACE::SubresourceLayout2 layout; 15371 getDispatcher()->vkGetDeviceImageSubresourceLayout( static_cast<VkDevice>( m_device ), 15372 reinterpret_cast<const VkDeviceImageSubresourceInfo *>( &info ), 15373 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 15374 15375 return layout; 15376 } 15377 15378 template <typename X, typename Y, typename... Z> 15379 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayout(const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info) const15380 Device::getImageSubresourceLayout( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT 15381 { 15382 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayout && 15383 "Function <vkGetDeviceImageSubresourceLayout> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 15384 15385 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 15386 VULKAN_HPP_NAMESPACE::SubresourceLayout2 & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2>(); 15387 getDispatcher()->vkGetDeviceImageSubresourceLayout( static_cast<VkDevice>( m_device ), 15388 reinterpret_cast<const VkDeviceImageSubresourceInfo *>( &info ), 15389 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 15390 15391 return structureChain; 15392 } 15393 15394 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2 getSubresourceLayout2(const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource) const15395 Image::getSubresourceLayout2( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT 15396 { 15397 VULKAN_HPP_ASSERT( 15398 getDispatcher()->vkGetImageSubresourceLayout2 && 15399 "Function <vkGetImageSubresourceLayout2> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 15400 15401 VULKAN_HPP_NAMESPACE::SubresourceLayout2 layout; 15402 getDispatcher()->vkGetImageSubresourceLayout2( static_cast<VkDevice>( m_device ), 15403 static_cast<VkImage>( m_image ), 15404 reinterpret_cast<const VkImageSubresource2 *>( &subresource ), 15405 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 15406 15407 return layout; 15408 } 15409 15410 template <typename X, typename Y, typename... Z> 15411 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getSubresourceLayout2(const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource) const15412 Image::getSubresourceLayout2( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT 15413 { 15414 VULKAN_HPP_ASSERT( 15415 getDispatcher()->vkGetImageSubresourceLayout2 && 15416 "Function <vkGetImageSubresourceLayout2> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 15417 15418 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 15419 VULKAN_HPP_NAMESPACE::SubresourceLayout2 & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2>(); 15420 getDispatcher()->vkGetImageSubresourceLayout2( static_cast<VkDevice>( m_device ), 15421 static_cast<VkImage>( m_image ), 15422 reinterpret_cast<const VkImageSubresource2 *>( &subresource ), 15423 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 15424 15425 return structureChain; 15426 } 15427 pushDescriptorSet(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t set,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites) const15428 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet( 15429 VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 15430 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 15431 uint32_t set, 15432 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT 15433 { 15434 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet && "Function <vkCmdPushDescriptorSet> requires <VK_KHR_push_descriptor> or <VK_VERSION_1_4>" ); 15435 15436 getDispatcher()->vkCmdPushDescriptorSet( static_cast<VkCommandBuffer>( m_commandBuffer ), 15437 static_cast<VkPipelineBindPoint>( pipelineBindPoint ), 15438 static_cast<VkPipelineLayout>( layout ), 15439 set, 15440 descriptorWrites.size(), 15441 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) ); 15442 } 15443 15444 template <typename DataType> pushDescriptorSetWithTemplate(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t set,DataType const & data) const15445 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 15446 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 15447 uint32_t set, 15448 DataType const & data ) const VULKAN_HPP_NOEXCEPT 15449 { 15450 VULKAN_HPP_ASSERT( 15451 getDispatcher()->vkCmdPushDescriptorSetWithTemplate && 15452 "Function <vkCmdPushDescriptorSetWithTemplate> requires <VK_KHR_descriptor_update_template> or <VK_KHR_push_descriptor> or <VK_VERSION_1_4>" ); 15453 15454 getDispatcher()->vkCmdPushDescriptorSetWithTemplate( static_cast<VkCommandBuffer>( m_commandBuffer ), 15455 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), 15456 static_cast<VkPipelineLayout>( layout ), 15457 set, 15458 reinterpret_cast<const void *>( &data ) ); 15459 } 15460 15461 VULKAN_HPP_INLINE void setRenderingAttachmentLocations(const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo) const15462 CommandBuffer::setRenderingAttachmentLocations( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT 15463 { 15464 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingAttachmentLocations && 15465 "Function <vkCmdSetRenderingAttachmentLocations> requires <VK_KHR_dynamic_rendering_local_read> or <VK_VERSION_1_4>" ); 15466 15467 getDispatcher()->vkCmdSetRenderingAttachmentLocations( static_cast<VkCommandBuffer>( m_commandBuffer ), 15468 reinterpret_cast<const VkRenderingAttachmentLocationInfo *>( &locationInfo ) ); 15469 } 15470 setRenderingInputAttachmentIndices(const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo) const15471 VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndices( 15472 const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT 15473 { 15474 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingInputAttachmentIndices && 15475 "Function <vkCmdSetRenderingInputAttachmentIndices> requires <VK_KHR_dynamic_rendering_local_read> or <VK_VERSION_1_4>" ); 15476 15477 getDispatcher()->vkCmdSetRenderingInputAttachmentIndices( static_cast<VkCommandBuffer>( m_commandBuffer ), 15478 reinterpret_cast<const VkRenderingInputAttachmentIndexInfo *>( &inputAttachmentIndexInfo ) ); 15479 } 15480 15481 VULKAN_HPP_INLINE void bindDescriptorSets2(const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo) const15482 CommandBuffer::bindDescriptorSets2( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT 15483 { 15484 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets2 && 15485 "Function <vkCmdBindDescriptorSets2> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" ); 15486 15487 getDispatcher()->vkCmdBindDescriptorSets2( static_cast<VkCommandBuffer>( m_commandBuffer ), 15488 reinterpret_cast<const VkBindDescriptorSetsInfo *>( &bindDescriptorSetsInfo ) ); 15489 } 15490 pushConstants2(const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo) const15491 VULKAN_HPP_INLINE void CommandBuffer::pushConstants2( const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT 15492 { 15493 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants2 && "Function <vkCmdPushConstants2> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" ); 15494 15495 getDispatcher()->vkCmdPushConstants2( static_cast<VkCommandBuffer>( m_commandBuffer ), 15496 reinterpret_cast<const VkPushConstantsInfo *>( &pushConstantsInfo ) ); 15497 } 15498 15499 VULKAN_HPP_INLINE void pushDescriptorSet2(const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo) const15500 CommandBuffer::pushDescriptorSet2( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT 15501 { 15502 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet2 && "Function <vkCmdPushDescriptorSet2> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" ); 15503 15504 getDispatcher()->vkCmdPushDescriptorSet2( static_cast<VkCommandBuffer>( m_commandBuffer ), 15505 reinterpret_cast<const VkPushDescriptorSetInfo *>( &pushDescriptorSetInfo ) ); 15506 } 15507 pushDescriptorSetWithTemplate2(const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo) const15508 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2( 15509 const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT 15510 { 15511 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetWithTemplate2 && 15512 "Function <vkCmdPushDescriptorSetWithTemplate2> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" ); 15513 15514 getDispatcher()->vkCmdPushDescriptorSetWithTemplate2( 15515 static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo *>( &pushDescriptorSetWithTemplateInfo ) ); 15516 } 15517 copyMemoryToImage(const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo) const15518 VULKAN_HPP_INLINE void Device::copyMemoryToImage( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo ) const 15519 { 15520 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToImage && "Function <vkCopyMemoryToImage> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" ); 15521 15522 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyMemoryToImage( 15523 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyMemoryToImageInfo *>( ©MemoryToImageInfo ) ) ); 15524 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImage" ); 15525 } 15526 copyImageToMemory(const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo) const15527 VULKAN_HPP_INLINE void Device::copyImageToMemory( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo ) const 15528 { 15529 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToMemory && "Function <vkCopyImageToMemory> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" ); 15530 15531 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyImageToMemory( 15532 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToMemoryInfo *>( ©ImageToMemoryInfo ) ) ); 15533 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemory" ); 15534 } 15535 copyImageToImage(const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo) const15536 VULKAN_HPP_INLINE void Device::copyImageToImage( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo ) const 15537 { 15538 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToImage && "Function <vkCopyImageToImage> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" ); 15539 15540 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15541 getDispatcher()->vkCopyImageToImage( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToImageInfo *>( ©ImageToImageInfo ) ) ); 15542 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImage" ); 15543 } 15544 15545 VULKAN_HPP_INLINE void transitionImageLayout(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions) const15546 Device::transitionImageLayout( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions ) const 15547 { 15548 VULKAN_HPP_ASSERT( getDispatcher()->vkTransitionImageLayout && 15549 "Function <vkTransitionImageLayout> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" ); 15550 15551 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkTransitionImageLayout( 15552 static_cast<VkDevice>( m_device ), transitions.size(), reinterpret_cast<const VkHostImageLayoutTransitionInfo *>( transitions.data() ) ) ); 15553 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayout" ); 15554 } 15555 15556 //=== VK_KHR_surface === 15557 getSurfaceSupportKHR(uint32_t queueFamilyIndex,VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const15558 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, 15559 VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 15560 { 15561 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR && "Function <vkGetPhysicalDeviceSurfaceSupportKHR> requires <VK_KHR_surface>" ); 15562 15563 VULKAN_HPP_NAMESPACE::Bool32 supported; 15564 VULKAN_HPP_NAMESPACE::Result result = 15565 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 15566 queueFamilyIndex, 15567 static_cast<VkSurfaceKHR>( surface ), 15568 reinterpret_cast<VkBool32 *>( &supported ) ) ); 15569 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); 15570 15571 return supported; 15572 } 15573 15574 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR getSurfaceCapabilitiesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const15575 PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 15576 { 15577 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR && 15578 "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> requires <VK_KHR_surface>" ); 15579 15580 VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities; 15581 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15582 getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 15583 static_cast<VkSurfaceKHR>( surface ), 15584 reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) ); 15585 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); 15586 15587 return surfaceCapabilities; 15588 } 15589 15590 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> getSurfaceFormatsKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const15591 PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 15592 { 15593 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR && "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> requires <VK_KHR_surface>" ); 15594 15595 std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> surfaceFormats; 15596 uint32_t surfaceFormatCount; 15597 VULKAN_HPP_NAMESPACE::Result result; 15598 do 15599 { 15600 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( 15601 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) ); 15602 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) 15603 { 15604 surfaceFormats.resize( surfaceFormatCount ); 15605 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15606 getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 15607 static_cast<VkSurfaceKHR>( surface ), 15608 &surfaceFormatCount, 15609 reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) ); 15610 } 15611 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15612 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); 15613 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); 15614 if ( surfaceFormatCount < surfaceFormats.size() ) 15615 { 15616 surfaceFormats.resize( surfaceFormatCount ); 15617 } 15618 return surfaceFormats; 15619 } 15620 15621 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> getSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const15622 PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 15623 { 15624 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR && 15625 "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> requires <VK_KHR_surface>" ); 15626 15627 std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes; 15628 uint32_t presentModeCount; 15629 VULKAN_HPP_NAMESPACE::Result result; 15630 do 15631 { 15632 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( 15633 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) ); 15634 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount ) 15635 { 15636 presentModes.resize( presentModeCount ); 15637 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15638 getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 15639 static_cast<VkSurfaceKHR>( surface ), 15640 &presentModeCount, 15641 reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); 15642 } 15643 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15644 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); 15645 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); 15646 if ( presentModeCount < presentModes.size() ) 15647 { 15648 presentModes.resize( presentModeCount ); 15649 } 15650 return presentModes; 15651 } 15652 15653 //=== VK_KHR_swapchain === 15654 15655 VULKAN_HPP_NODISCARD 15656 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>::Type createSwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const15657 Device::createSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 15658 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 15659 VULKAN_HPP_RAII_CREATE_NOEXCEPT 15660 { 15661 VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; 15662 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSwapchainKHR( 15663 static_cast<VkDevice>( m_device ), 15664 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), 15665 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 15666 reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); 15667 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15668 { 15669 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 15670 return VULKAN_HPP_UNEXPECTED( result ); 15671 # else 15672 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSwapchainKHR" ); 15673 # endif 15674 } 15675 15676 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, *reinterpret_cast<VkSwapchainKHR *>( &swapchain ), allocator ); 15677 } 15678 getImages() const15679 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Image> SwapchainKHR::getImages() const 15680 { 15681 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> requires <VK_KHR_swapchain>" ); 15682 15683 std::vector<VULKAN_HPP_NAMESPACE::Image> swapchainImages; 15684 uint32_t swapchainImageCount; 15685 VULKAN_HPP_NAMESPACE::Result result; 15686 do 15687 { 15688 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainImagesKHR( 15689 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), &swapchainImageCount, nullptr ) ); 15690 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount ) 15691 { 15692 swapchainImages.resize( swapchainImageCount ); 15693 result = 15694 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ), 15695 static_cast<VkSwapchainKHR>( m_swapchain ), 15696 &swapchainImageCount, 15697 reinterpret_cast<VkImage *>( swapchainImages.data() ) ) ); 15698 } 15699 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15700 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getImages" ); 15701 VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); 15702 if ( swapchainImageCount < swapchainImages.size() ) 15703 { 15704 swapchainImages.resize( swapchainImageCount ); 15705 } 15706 return swapchainImages; 15707 } 15708 15709 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) const15710 SwapchainKHR::acquireNextImage( uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence ) const 15711 { 15712 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImageKHR && "Function <vkAcquireNextImageKHR> requires <VK_KHR_swapchain>" ); 15713 15714 uint32_t imageIndex; 15715 VULKAN_HPP_NAMESPACE::Result result = 15716 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireNextImageKHR( static_cast<VkDevice>( m_device ), 15717 static_cast<VkSwapchainKHR>( m_swapchain ), 15718 timeout, 15719 static_cast<VkSemaphore>( semaphore ), 15720 static_cast<VkFence>( fence ), 15721 &imageIndex ) ); 15722 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 15723 VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage", 15724 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 15725 VULKAN_HPP_NAMESPACE::Result::eTimeout, 15726 VULKAN_HPP_NAMESPACE::Result::eNotReady, 15727 VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); 15728 15729 return std::make_pair( result, std::move( imageIndex ) ); 15730 } 15731 presentKHR(const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo) const15732 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo ) const 15733 { 15734 VULKAN_HPP_ASSERT( getDispatcher()->vkQueuePresentKHR && "Function <vkQueuePresentKHR> requires <VK_KHR_swapchain>" ); 15735 15736 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15737 getDispatcher()->vkQueuePresentKHR( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) ); 15738 VULKAN_HPP_NAMESPACE::detail::resultCheck( 15739 result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); 15740 15741 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 15742 } 15743 getGroupPresentCapabilitiesKHR() const15744 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR Device::getGroupPresentCapabilitiesKHR() const 15745 { 15746 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR && 15747 "Function <vkGetDeviceGroupPresentCapabilitiesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" ); 15748 15749 VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; 15750 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR( 15751 static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) ); 15752 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); 15753 15754 return deviceGroupPresentCapabilities; 15755 } 15756 15757 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR getGroupSurfacePresentModesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const15758 Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 15759 { 15760 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR && 15761 "Function <vkGetDeviceGroupSurfacePresentModesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" ); 15762 15763 VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; 15764 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR( 15765 static_cast<VkDevice>( m_device ), static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) ); 15766 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); 15767 15768 return modes; 15769 } 15770 15771 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Rect2D> getPresentRectanglesKHR(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const15772 PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 15773 { 15774 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR && 15775 "Function <vkGetPhysicalDevicePresentRectanglesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" ); 15776 15777 std::vector<VULKAN_HPP_NAMESPACE::Rect2D> rects; 15778 uint32_t rectCount; 15779 VULKAN_HPP_NAMESPACE::Result result; 15780 do 15781 { 15782 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( 15783 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) ); 15784 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && rectCount ) 15785 { 15786 rects.resize( rectCount ); 15787 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15788 getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 15789 static_cast<VkSurfaceKHR>( surface ), 15790 &rectCount, 15791 reinterpret_cast<VkRect2D *>( rects.data() ) ) ); 15792 } 15793 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15794 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); 15795 VULKAN_HPP_ASSERT( rectCount <= rects.size() ); 15796 if ( rectCount < rects.size() ) 15797 { 15798 rects.resize( rectCount ); 15799 } 15800 return rects; 15801 } 15802 15803 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t> acquireNextImage2KHR(const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo) const15804 Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo ) const 15805 { 15806 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImage2KHR && "Function <vkAcquireNextImage2KHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" ); 15807 15808 uint32_t imageIndex; 15809 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireNextImage2KHR( 15810 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ), &imageIndex ) ); 15811 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 15812 VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", 15813 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 15814 VULKAN_HPP_NAMESPACE::Result::eTimeout, 15815 VULKAN_HPP_NAMESPACE::Result::eNotReady, 15816 VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); 15817 15818 return std::make_pair( result, std::move( imageIndex ) ); 15819 } 15820 15821 //=== VK_KHR_display === 15822 getDisplayPropertiesKHR() const15823 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> PhysicalDevice::getDisplayPropertiesKHR() const 15824 { 15825 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR && 15826 "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> requires <VK_KHR_display>" ); 15827 15828 std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> properties; 15829 uint32_t propertyCount; 15830 VULKAN_HPP_NAMESPACE::Result result; 15831 do 15832 { 15833 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15834 getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 15835 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 15836 { 15837 properties.resize( propertyCount ); 15838 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( 15839 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) ); 15840 } 15841 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15842 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); 15843 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 15844 if ( propertyCount < properties.size() ) 15845 { 15846 properties.resize( propertyCount ); 15847 } 15848 return properties; 15849 } 15850 getDisplayPlanePropertiesKHR() const15851 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> PhysicalDevice::getDisplayPlanePropertiesKHR() const 15852 { 15853 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR && 15854 "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> requires <VK_KHR_display>" ); 15855 15856 std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> properties; 15857 uint32_t propertyCount; 15858 VULKAN_HPP_NAMESPACE::Result result; 15859 do 15860 { 15861 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15862 getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 15863 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 15864 { 15865 properties.resize( propertyCount ); 15866 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 15867 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) ); 15868 } 15869 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15870 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); 15871 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 15872 if ( propertyCount < properties.size() ) 15873 { 15874 properties.resize( propertyCount ); 15875 } 15876 return properties; 15877 } 15878 15879 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 15880 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>>::Type getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex) const15881 PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const 15882 { 15883 std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR> displays; 15884 uint32_t displayCount; 15885 VULKAN_HPP_NAMESPACE::Result result; 15886 do 15887 { 15888 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15889 getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), planeIndex, &displayCount, nullptr ) ); 15890 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && displayCount ) 15891 { 15892 displays.resize( displayCount ); 15893 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR( 15894 static_cast<VkPhysicalDevice>( m_physicalDevice ), planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) ); 15895 } 15896 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15897 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncomplete ) ) 15898 { 15899 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 15900 return VULKAN_HPP_UNEXPECTED( result ); 15901 # else 15902 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); 15903 # endif 15904 } 15905 15906 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> displaysRAII; 15907 displaysRAII.reserve( displays.size() ); 15908 for ( auto & display : displays ) 15909 { 15910 displaysRAII.emplace_back( *this, *reinterpret_cast<VkDisplayKHR *>( &display ) ); 15911 } 15912 return displaysRAII; 15913 } 15914 getModeProperties() const15915 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> DisplayKHR::getModeProperties() const 15916 { 15917 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModePropertiesKHR && "Function <vkGetDisplayModePropertiesKHR> requires <VK_KHR_display>" ); 15918 15919 std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> properties; 15920 uint32_t propertyCount; 15921 VULKAN_HPP_NAMESPACE::Result result; 15922 do 15923 { 15924 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModePropertiesKHR( 15925 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ), &propertyCount, nullptr ) ); 15926 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 15927 { 15928 properties.resize( propertyCount ); 15929 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15930 getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 15931 static_cast<VkDisplayKHR>( m_display ), 15932 &propertyCount, 15933 reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) ); 15934 } 15935 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 15936 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties" ); 15937 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 15938 if ( propertyCount < properties.size() ) 15939 { 15940 properties.resize( propertyCount ); 15941 } 15942 return properties; 15943 } 15944 15945 VULKAN_HPP_NODISCARD 15946 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR>::Type createMode(VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const15947 DisplayKHR::createMode( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo, 15948 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 15949 { 15950 VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; 15951 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDisplayModeKHR( 15952 static_cast<VkPhysicalDevice>( m_physicalDevice ), 15953 static_cast<VkDisplayKHR>( m_display ), 15954 reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ), 15955 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 15956 reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) ); 15957 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15958 { 15959 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 15960 return VULKAN_HPP_UNEXPECTED( result ); 15961 # else 15962 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "DisplayKHR::createMode" ); 15963 # endif 15964 } 15965 15966 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR( *this, *reinterpret_cast<VkDisplayModeKHR *>( &mode ) ); 15967 } 15968 15969 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR getDisplayPlaneCapabilities(uint32_t planeIndex) const15970 DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex ) const 15971 { 15972 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR && "Function <vkGetDisplayPlaneCapabilitiesKHR> requires <VK_KHR_display>" ); 15973 15974 VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities; 15975 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 15976 getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 15977 static_cast<VkDisplayModeKHR>( m_displayModeKHR ), 15978 planeIndex, 15979 reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) ); 15980 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" ); 15981 15982 return capabilities; 15983 } 15984 15985 VULKAN_HPP_NODISCARD 15986 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createDisplayPlaneSurfaceKHR(VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const15987 Instance::createDisplayPlaneSurfaceKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo, 15988 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 15989 VULKAN_HPP_RAII_CREATE_NOEXCEPT 15990 { 15991 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 15992 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDisplayPlaneSurfaceKHR( 15993 static_cast<VkInstance>( m_instance ), 15994 reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ), 15995 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 15996 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 15997 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 15998 { 15999 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16000 return VULKAN_HPP_UNEXPECTED( result ); 16001 # else 16002 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createDisplayPlaneSurfaceKHR" ); 16003 # endif 16004 } 16005 16006 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 16007 } 16008 16009 //=== VK_KHR_display_swapchain === 16010 16011 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 16012 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>>::Type createSharedSwapchainsKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16013 Device::createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos, 16014 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16015 { 16016 std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR> swapchains( createInfos.size() ); 16017 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSharedSwapchainsKHR( 16018 static_cast<VkDevice>( m_device ), 16019 createInfos.size(), 16020 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ), 16021 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16022 reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) ); 16023 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16024 { 16025 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16026 return VULKAN_HPP_UNEXPECTED( result ); 16027 # else 16028 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSharedSwapchainsKHR" ); 16029 # endif 16030 } 16031 16032 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> swapchainsRAII; 16033 swapchainsRAII.reserve( swapchains.size() ); 16034 for ( auto & swapchain : swapchains ) 16035 { 16036 swapchainsRAII.emplace_back( *this, *reinterpret_cast<VkSwapchainKHR *>( &swapchain ), allocator ); 16037 } 16038 return swapchainsRAII; 16039 } 16040 16041 VULKAN_HPP_NODISCARD 16042 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>::Type createSharedSwapchainKHR(VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16043 Device::createSharedSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo, 16044 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16045 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16046 { 16047 VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; 16048 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSharedSwapchainsKHR( 16049 static_cast<VkDevice>( m_device ), 16050 1, 16051 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ), 16052 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16053 reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) ); 16054 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16055 { 16056 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16057 return VULKAN_HPP_UNEXPECTED( result ); 16058 # else 16059 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSharedSwapchainKHR" ); 16060 # endif 16061 } 16062 16063 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, *reinterpret_cast<VkSwapchainKHR *>( &swapchain ), allocator ); 16064 } 16065 16066 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 16067 //=== VK_KHR_xlib_surface === 16068 16069 VULKAN_HPP_NODISCARD 16070 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createXlibSurfaceKHR(VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16071 Instance::createXlibSurfaceKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo, 16072 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16073 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16074 { 16075 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 16076 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateXlibSurfaceKHR( 16077 static_cast<VkInstance>( m_instance ), 16078 reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ), 16079 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16080 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 16081 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16082 { 16083 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16084 return VULKAN_HPP_UNEXPECTED( result ); 16085 # else 16086 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createXlibSurfaceKHR" ); 16087 # endif 16088 } 16089 16090 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 16091 } 16092 16093 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getXlibPresentationSupportKHR(uint32_t queueFamilyIndex,Display & dpy,VisualID visualID) const16094 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT 16095 { 16096 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR && 16097 "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> requires <VK_KHR_xlib_surface>" ); 16098 16099 VkBool32 result = 16100 getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dpy, visualID ); 16101 16102 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); 16103 } 16104 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 16105 16106 # if defined( VK_USE_PLATFORM_XCB_KHR ) 16107 //=== VK_KHR_xcb_surface === 16108 16109 VULKAN_HPP_NODISCARD 16110 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createXcbSurfaceKHR(VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16111 Instance::createXcbSurfaceKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo, 16112 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16113 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16114 { 16115 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 16116 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateXcbSurfaceKHR( 16117 static_cast<VkInstance>( m_instance ), 16118 reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ), 16119 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16120 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 16121 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16122 { 16123 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16124 return VULKAN_HPP_UNEXPECTED( result ); 16125 # else 16126 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createXcbSurfaceKHR" ); 16127 # endif 16128 } 16129 16130 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 16131 } 16132 getXcbPresentationSupportKHR(uint32_t queueFamilyIndex,xcb_connection_t & connection,xcb_visualid_t visual_id) const16133 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR( 16134 uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT 16135 { 16136 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR && 16137 "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> requires <VK_KHR_xcb_surface>" ); 16138 16139 VkBool32 result = getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR( 16140 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &connection, visual_id ); 16141 16142 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); 16143 } 16144 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 16145 16146 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 16147 //=== VK_KHR_wayland_surface === 16148 16149 VULKAN_HPP_NODISCARD 16150 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createWaylandSurfaceKHR(VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16151 Instance::createWaylandSurfaceKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo, 16152 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16153 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16154 { 16155 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 16156 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateWaylandSurfaceKHR( 16157 static_cast<VkInstance>( m_instance ), 16158 reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ), 16159 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16160 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 16161 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16162 { 16163 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16164 return VULKAN_HPP_UNEXPECTED( result ); 16165 # else 16166 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createWaylandSurfaceKHR" ); 16167 # endif 16168 } 16169 16170 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 16171 } 16172 16173 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR(uint32_t queueFamilyIndex,struct wl_display & display) const16174 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const VULKAN_HPP_NOEXCEPT 16175 { 16176 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR && 16177 "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> requires <VK_KHR_wayland_surface>" ); 16178 16179 VkBool32 result = 16180 getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &display ); 16181 16182 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); 16183 } 16184 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 16185 16186 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 16187 //=== VK_KHR_android_surface === 16188 16189 VULKAN_HPP_NODISCARD 16190 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createAndroidSurfaceKHR(VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16191 Instance::createAndroidSurfaceKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo, 16192 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16193 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16194 { 16195 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 16196 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateAndroidSurfaceKHR( 16197 static_cast<VkInstance>( m_instance ), 16198 reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ), 16199 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16200 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 16201 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16202 { 16203 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16204 return VULKAN_HPP_UNEXPECTED( result ); 16205 # else 16206 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createAndroidSurfaceKHR" ); 16207 # endif 16208 } 16209 16210 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 16211 } 16212 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 16213 16214 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 16215 //=== VK_KHR_win32_surface === 16216 16217 VULKAN_HPP_NODISCARD 16218 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createWin32SurfaceKHR(VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16219 Instance::createWin32SurfaceKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo, 16220 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16221 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16222 { 16223 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 16224 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateWin32SurfaceKHR( 16225 static_cast<VkInstance>( m_instance ), 16226 reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ), 16227 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16228 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 16229 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16230 { 16231 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16232 return VULKAN_HPP_UNEXPECTED( result ); 16233 # else 16234 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createWin32SurfaceKHR" ); 16235 # endif 16236 } 16237 16238 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 16239 } 16240 16241 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getWin32PresentationSupportKHR(uint32_t queueFamilyIndex) const16242 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT 16243 { 16244 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR && 16245 "Function <vkGetPhysicalDeviceWin32PresentationSupportKHR> requires <VK_KHR_win32_surface>" ); 16246 16247 VkBool32 result = getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex ); 16248 16249 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); 16250 } 16251 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 16252 16253 //=== VK_EXT_debug_report === 16254 16255 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 16256 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT>::Type createDebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16257 Instance::createDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo, 16258 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16259 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16260 { 16261 VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; 16262 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDebugReportCallbackEXT( 16263 static_cast<VkInstance>( m_instance ), 16264 reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ), 16265 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16266 reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) ); 16267 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16268 { 16269 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16270 return VULKAN_HPP_UNEXPECTED( result ); 16271 # else 16272 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createDebugReportCallbackEXT" ); 16273 # endif 16274 } 16275 16276 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT( 16277 *this, *reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ), allocator ); 16278 } 16279 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) const16280 VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags, 16281 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_, 16282 uint64_t object, 16283 size_t location, 16284 int32_t messageCode, 16285 const std::string & layerPrefix, 16286 const std::string & message ) const VULKAN_HPP_NOEXCEPT 16287 { 16288 VULKAN_HPP_ASSERT( getDispatcher()->vkDebugReportMessageEXT && "Function <vkDebugReportMessageEXT> requires <VK_EXT_debug_report>" ); 16289 16290 getDispatcher()->vkDebugReportMessageEXT( static_cast<VkInstance>( m_instance ), 16291 static_cast<VkDebugReportFlagsEXT>( flags ), 16292 static_cast<VkDebugReportObjectTypeEXT>( objectType_ ), 16293 object, 16294 location, 16295 messageCode, 16296 layerPrefix.c_str(), 16297 message.c_str() ); 16298 } 16299 16300 //=== VK_EXT_debug_marker === 16301 debugMarkerSetObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo) const16302 VULKAN_HPP_INLINE void Device::debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo ) const 16303 { 16304 VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectTagEXT && "Function <vkDebugMarkerSetObjectTagEXT> requires <VK_EXT_debug_marker>" ); 16305 16306 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectTagEXT( 16307 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) ); 16308 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); 16309 } 16310 debugMarkerSetObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo) const16311 VULKAN_HPP_INLINE void Device::debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo ) const 16312 { 16313 VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectNameEXT && "Function <vkDebugMarkerSetObjectNameEXT> requires <VK_EXT_debug_marker>" ); 16314 16315 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectNameEXT( 16316 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) ); 16317 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); 16318 } 16319 debugMarkerBeginEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo) const16320 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT 16321 { 16322 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerBeginEXT && "Function <vkCmdDebugMarkerBeginEXT> requires <VK_EXT_debug_marker>" ); 16323 16324 getDispatcher()->vkCmdDebugMarkerBeginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16325 reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) ); 16326 } 16327 debugMarkerEndEXT() const16328 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT 16329 { 16330 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerEndEXT && "Function <vkCmdDebugMarkerEndEXT> requires <VK_EXT_debug_marker>" ); 16331 16332 getDispatcher()->vkCmdDebugMarkerEndEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 16333 } 16334 debugMarkerInsertEXT(const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo) const16335 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT 16336 { 16337 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerInsertEXT && "Function <vkCmdDebugMarkerInsertEXT> requires <VK_EXT_debug_marker>" ); 16338 16339 getDispatcher()->vkCmdDebugMarkerInsertEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16340 reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) ); 16341 } 16342 16343 //=== VK_KHR_video_queue === 16344 16345 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile) const16346 PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const 16347 { 16348 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && 16349 "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" ); 16350 16351 VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities; 16352 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16353 getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 16354 reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ), 16355 reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) ); 16356 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); 16357 16358 return capabilities; 16359 } 16360 16361 template <typename X, typename Y, typename... Z> 16362 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getVideoCapabilitiesKHR(const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile) const16363 PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const 16364 { 16365 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && 16366 "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" ); 16367 16368 StructureChain<X, Y, Z...> structureChain; 16369 VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>(); 16370 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16371 getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 16372 reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ), 16373 reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) ); 16374 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); 16375 16376 return structureChain; 16377 } 16378 16379 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> getVideoFormatPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo) const16380 PhysicalDevice::getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const 16381 { 16382 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR && 16383 "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" ); 16384 16385 std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> videoFormatProperties; 16386 uint32_t videoFormatPropertyCount; 16387 VULKAN_HPP_NAMESPACE::Result result; 16388 do 16389 { 16390 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16391 getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 16392 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), 16393 &videoFormatPropertyCount, 16394 nullptr ) ); 16395 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoFormatPropertyCount ) 16396 { 16397 videoFormatProperties.resize( videoFormatPropertyCount ); 16398 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16399 getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 16400 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ), 16401 &videoFormatPropertyCount, 16402 reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) ); 16403 } 16404 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16405 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); 16406 VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); 16407 if ( videoFormatPropertyCount < videoFormatProperties.size() ) 16408 { 16409 videoFormatProperties.resize( videoFormatPropertyCount ); 16410 } 16411 return videoFormatProperties; 16412 } 16413 16414 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 16415 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR>::Type createVideoSessionKHR(VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16416 Device::createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo, 16417 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16418 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16419 { 16420 VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; 16421 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateVideoSessionKHR( 16422 static_cast<VkDevice>( m_device ), 16423 reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ), 16424 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16425 reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) ); 16426 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16427 { 16428 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16429 return VULKAN_HPP_UNEXPECTED( result ); 16430 # else 16431 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createVideoSessionKHR" ); 16432 # endif 16433 } 16434 16435 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR( *this, *reinterpret_cast<VkVideoSessionKHR *>( &videoSession ), allocator ); 16436 } 16437 getMemoryRequirements() const16438 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> VideoSessionKHR::getMemoryRequirements() const 16439 { 16440 VULKAN_HPP_ASSERT( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR && 16441 "Function <vkGetVideoSessionMemoryRequirementsKHR> requires <VK_KHR_video_queue>" ); 16442 16443 std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> memoryRequirements; 16444 uint32_t memoryRequirementsCount; 16445 VULKAN_HPP_NAMESPACE::Result result; 16446 do 16447 { 16448 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( 16449 static_cast<VkDevice>( m_device ), static_cast<VkVideoSessionKHR>( m_videoSession ), &memoryRequirementsCount, nullptr ) ); 16450 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && memoryRequirementsCount ) 16451 { 16452 memoryRequirements.resize( memoryRequirementsCount ); 16453 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16454 getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( m_device ), 16455 static_cast<VkVideoSessionKHR>( m_videoSession ), 16456 &memoryRequirementsCount, 16457 reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) ); 16458 } 16459 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16460 16461 VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); 16462 if ( memoryRequirementsCount < memoryRequirements.size() ) 16463 { 16464 memoryRequirements.resize( memoryRequirementsCount ); 16465 } 16466 return memoryRequirements; 16467 } 16468 bindMemory(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos) const16469 VULKAN_HPP_INLINE void VideoSessionKHR::bindMemory( 16470 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos ) const 16471 { 16472 VULKAN_HPP_ASSERT( getDispatcher()->vkBindVideoSessionMemoryKHR && "Function <vkBindVideoSessionMemoryKHR> requires <VK_KHR_video_queue>" ); 16473 16474 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16475 getDispatcher()->vkBindVideoSessionMemoryKHR( static_cast<VkDevice>( m_device ), 16476 static_cast<VkVideoSessionKHR>( m_videoSession ), 16477 bindSessionMemoryInfos.size(), 16478 reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR *>( bindSessionMemoryInfos.data() ) ) ); 16479 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::bindMemory" ); 16480 } 16481 16482 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 16483 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR>::Type createVideoSessionParametersKHR(VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16484 Device::createVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo, 16485 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16486 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16487 { 16488 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; 16489 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateVideoSessionParametersKHR( 16490 static_cast<VkDevice>( m_device ), 16491 reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ), 16492 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16493 reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) ); 16494 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16495 { 16496 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16497 return VULKAN_HPP_UNEXPECTED( result ); 16498 # else 16499 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createVideoSessionParametersKHR" ); 16500 # endif 16501 } 16502 16503 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR( 16504 *this, *reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ), allocator ); 16505 } 16506 update(const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo) const16507 VULKAN_HPP_INLINE void VideoSessionParametersKHR::update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const 16508 { 16509 VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateVideoSessionParametersKHR && "Function <vkUpdateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" ); 16510 16511 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 16512 getDispatcher()->vkUpdateVideoSessionParametersKHR( static_cast<VkDevice>( m_device ), 16513 static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ), 16514 reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) ); 16515 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionParametersKHR::update" ); 16516 } 16517 beginVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo) const16518 VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT 16519 { 16520 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginVideoCodingKHR && "Function <vkCmdBeginVideoCodingKHR> requires <VK_KHR_video_queue>" ); 16521 16522 getDispatcher()->vkCmdBeginVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 16523 reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) ); 16524 } 16525 endVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo) const16526 VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT 16527 { 16528 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndVideoCodingKHR && "Function <vkCmdEndVideoCodingKHR> requires <VK_KHR_video_queue>" ); 16529 16530 getDispatcher()->vkCmdEndVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 16531 reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) ); 16532 } 16533 16534 VULKAN_HPP_INLINE void controlVideoCodingKHR(const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo) const16535 CommandBuffer::controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT 16536 { 16537 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdControlVideoCodingKHR && "Function <vkCmdControlVideoCodingKHR> requires <VK_KHR_video_queue>" ); 16538 16539 getDispatcher()->vkCmdControlVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 16540 reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) ); 16541 } 16542 16543 //=== VK_KHR_video_decode_queue === 16544 decodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo) const16545 VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT 16546 { 16547 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecodeVideoKHR && "Function <vkCmdDecodeVideoKHR> requires <VK_KHR_video_decode_queue>" ); 16548 16549 getDispatcher()->vkCmdDecodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoDecodeInfoKHR *>( &decodeInfo ) ); 16550 } 16551 16552 //=== VK_EXT_transform_feedback === 16553 16554 VULKAN_HPP_INLINE void bindTransformFeedbackBuffersEXT(uint32_t firstBinding,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes) const16555 CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, 16556 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 16557 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 16558 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes ) const 16559 { 16560 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT && 16561 "Function <vkCmdBindTransformFeedbackBuffersEXT> requires <VK_EXT_transform_feedback>" ); 16562 # ifdef VULKAN_HPP_NO_EXCEPTIONS 16563 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); 16564 VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); 16565 # else 16566 if ( buffers.size() != offsets.size() ) 16567 { 16568 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); 16569 } 16570 if ( !sizes.empty() && buffers.size() != sizes.size() ) 16571 { 16572 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); 16573 } 16574 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 16575 16576 getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16577 firstBinding, 16578 buffers.size(), 16579 reinterpret_cast<const VkBuffer *>( buffers.data() ), 16580 reinterpret_cast<const VkDeviceSize *>( offsets.data() ), 16581 reinterpret_cast<const VkDeviceSize *>( sizes.data() ) ); 16582 } 16583 16584 VULKAN_HPP_INLINE void beginTransformFeedbackEXT(uint32_t firstCounterBuffer,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets) const16585 CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, 16586 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, 16587 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const 16588 { 16589 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginTransformFeedbackEXT && "Function <vkCmdBeginTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" ); 16590 # ifdef VULKAN_HPP_NO_EXCEPTIONS 16591 VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); 16592 # else 16593 if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) 16594 { 16595 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); 16596 } 16597 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 16598 16599 getDispatcher()->vkCmdBeginTransformFeedbackEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16600 firstCounterBuffer, 16601 counterBuffers.size(), 16602 reinterpret_cast<const VkBuffer *>( counterBuffers.data() ), 16603 reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) ); 16604 } 16605 16606 VULKAN_HPP_INLINE void endTransformFeedbackEXT(uint32_t firstCounterBuffer,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets) const16607 CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, 16608 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers, 16609 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const 16610 { 16611 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndTransformFeedbackEXT && "Function <vkCmdEndTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" ); 16612 # ifdef VULKAN_HPP_NO_EXCEPTIONS 16613 VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); 16614 # else 16615 if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) 16616 { 16617 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); 16618 } 16619 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 16620 16621 getDispatcher()->vkCmdEndTransformFeedbackEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16622 firstCounterBuffer, 16623 counterBuffers.size(), 16624 reinterpret_cast<const VkBuffer *>( counterBuffers.data() ), 16625 reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) ); 16626 } 16627 beginQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query,VULKAN_HPP_NAMESPACE::QueryControlFlags flags,uint32_t index) const16628 VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, 16629 uint32_t query, 16630 VULKAN_HPP_NAMESPACE::QueryControlFlags flags, 16631 uint32_t index ) const VULKAN_HPP_NOEXCEPT 16632 { 16633 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQueryIndexedEXT && "Function <vkCmdBeginQueryIndexedEXT> requires <VK_EXT_transform_feedback>" ); 16634 16635 getDispatcher()->vkCmdBeginQueryIndexedEXT( 16636 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index ); 16637 } 16638 16639 VULKAN_HPP_INLINE void endQueryIndexedEXT(VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query,uint32_t index) const16640 CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT 16641 { 16642 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQueryIndexedEXT && "Function <vkCmdEndQueryIndexedEXT> requires <VK_EXT_transform_feedback>" ); 16643 16644 getDispatcher()->vkCmdEndQueryIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, index ); 16645 } 16646 drawIndirectByteCountEXT(uint32_t instanceCount,uint32_t firstInstance,VULKAN_HPP_NAMESPACE::Buffer counterBuffer,VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,uint32_t counterOffset,uint32_t vertexStride) const16647 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, 16648 uint32_t firstInstance, 16649 VULKAN_HPP_NAMESPACE::Buffer counterBuffer, 16650 VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset, 16651 uint32_t counterOffset, 16652 uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT 16653 { 16654 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectByteCountEXT && "Function <vkCmdDrawIndirectByteCountEXT> requires <VK_EXT_transform_feedback>" ); 16655 16656 getDispatcher()->vkCmdDrawIndirectByteCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 16657 instanceCount, 16658 firstInstance, 16659 static_cast<VkBuffer>( counterBuffer ), 16660 static_cast<VkDeviceSize>( counterBufferOffset ), 16661 counterOffset, 16662 vertexStride ); 16663 } 16664 16665 //=== VK_NVX_binary_import === 16666 16667 VULKAN_HPP_NODISCARD 16668 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX>::Type createCuModuleNVX(VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16669 Device::createCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo, 16670 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16671 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16672 { 16673 VULKAN_HPP_NAMESPACE::CuModuleNVX module; 16674 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCuModuleNVX( 16675 static_cast<VkDevice>( m_device ), 16676 reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ), 16677 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16678 reinterpret_cast<VkCuModuleNVX *>( &module ) ) ); 16679 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16680 { 16681 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16682 return VULKAN_HPP_UNEXPECTED( result ); 16683 # else 16684 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCuModuleNVX" ); 16685 # endif 16686 } 16687 16688 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX( *this, *reinterpret_cast<VkCuModuleNVX *>( &module ), allocator ); 16689 } 16690 16691 VULKAN_HPP_NODISCARD 16692 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX>::Type createCuFunctionNVX(VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16693 Device::createCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo, 16694 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16695 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16696 { 16697 VULKAN_HPP_NAMESPACE::CuFunctionNVX function; 16698 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCuFunctionNVX( 16699 static_cast<VkDevice>( m_device ), 16700 reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ), 16701 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16702 reinterpret_cast<VkCuFunctionNVX *>( &function ) ) ); 16703 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16704 { 16705 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16706 return VULKAN_HPP_UNEXPECTED( result ); 16707 # else 16708 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCuFunctionNVX" ); 16709 # endif 16710 } 16711 16712 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX( *this, *reinterpret_cast<VkCuFunctionNVX *>( &function ), allocator ); 16713 } 16714 cuLaunchKernelNVX(const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo) const16715 VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT 16716 { 16717 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCuLaunchKernelNVX && "Function <vkCmdCuLaunchKernelNVX> requires <VK_NVX_binary_import>" ); 16718 16719 getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) ); 16720 } 16721 16722 //=== VK_NVX_image_view_handle === 16723 16724 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t getImageViewHandleNVX(const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info) const16725 Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT 16726 { 16727 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandleNVX && "Function <vkGetImageViewHandleNVX> requires <VK_NVX_image_view_handle>" ); 16728 16729 uint32_t result = 16730 getDispatcher()->vkGetImageViewHandleNVX( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) ); 16731 16732 return result; 16733 } 16734 getAddressNVX() const16735 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX ImageView::getAddressNVX() const 16736 { 16737 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX && "Function <vkGetImageViewAddressNVX> requires <VK_NVX_image_view_handle>" ); 16738 16739 VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties; 16740 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageViewAddressNVX( 16741 static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) ); 16742 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ImageView::getAddressNVX" ); 16743 16744 return properties; 16745 } 16746 16747 //=== VK_AMD_draw_indirect_count === 16748 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) const16749 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, 16750 VULKAN_HPP_NAMESPACE::DeviceSize offset, 16751 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 16752 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 16753 uint32_t maxDrawCount, 16754 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 16755 { 16756 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountAMD && 16757 "Function <vkCmdDrawIndirectCountAMD> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" ); 16758 16759 getDispatcher()->vkCmdDrawIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ), 16760 static_cast<VkBuffer>( buffer ), 16761 static_cast<VkDeviceSize>( offset ), 16762 static_cast<VkBuffer>( countBuffer ), 16763 static_cast<VkDeviceSize>( countBufferOffset ), 16764 maxDrawCount, 16765 stride ); 16766 } 16767 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) const16768 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, 16769 VULKAN_HPP_NAMESPACE::DeviceSize offset, 16770 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 16771 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 16772 uint32_t maxDrawCount, 16773 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 16774 { 16775 VULKAN_HPP_ASSERT( 16776 getDispatcher()->vkCmdDrawIndexedIndirectCountAMD && 16777 "Function <vkCmdDrawIndexedIndirectCountAMD> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" ); 16778 16779 getDispatcher()->vkCmdDrawIndexedIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ), 16780 static_cast<VkBuffer>( buffer ), 16781 static_cast<VkDeviceSize>( offset ), 16782 static_cast<VkBuffer>( countBuffer ), 16783 static_cast<VkDeviceSize>( countBufferOffset ), 16784 maxDrawCount, 16785 stride ); 16786 } 16787 16788 //=== VK_AMD_shader_info === 16789 getShaderInfoAMD(VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType) const16790 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> Pipeline::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage, 16791 VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType ) const 16792 { 16793 VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> requires <VK_AMD_shader_info>" ); 16794 16795 std::vector<uint8_t> info; 16796 size_t infoSize; 16797 VULKAN_HPP_NAMESPACE::Result result; 16798 do 16799 { 16800 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ), 16801 static_cast<VkPipeline>( m_pipeline ), 16802 static_cast<VkShaderStageFlagBits>( shaderStage ), 16803 static_cast<VkShaderInfoTypeAMD>( infoType ), 16804 &infoSize, 16805 nullptr ) ); 16806 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && infoSize ) 16807 { 16808 info.resize( infoSize ); 16809 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ), 16810 static_cast<VkPipeline>( m_pipeline ), 16811 static_cast<VkShaderStageFlagBits>( shaderStage ), 16812 static_cast<VkShaderInfoTypeAMD>( infoType ), 16813 &infoSize, 16814 reinterpret_cast<void *>( info.data() ) ) ); 16815 } 16816 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 16817 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getShaderInfoAMD" ); 16818 VULKAN_HPP_ASSERT( infoSize <= info.size() ); 16819 if ( infoSize < info.size() ) 16820 { 16821 info.resize( infoSize ); 16822 } 16823 return info; 16824 } 16825 16826 //=== VK_KHR_dynamic_rendering === 16827 beginRenderingKHR(const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo) const16828 VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT 16829 { 16830 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderingKHR && 16831 "Function <vkCmdBeginRenderingKHR> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" ); 16832 16833 getDispatcher()->vkCmdBeginRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) ); 16834 } 16835 endRenderingKHR() const16836 VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR() const VULKAN_HPP_NOEXCEPT 16837 { 16838 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderingKHR && "Function <vkCmdEndRenderingKHR> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" ); 16839 16840 getDispatcher()->vkCmdEndRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 16841 } 16842 16843 # if defined( VK_USE_PLATFORM_GGP ) 16844 //=== VK_GGP_stream_descriptor_surface === 16845 16846 VULKAN_HPP_NODISCARD 16847 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createStreamDescriptorSurfaceGGP(VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const16848 Instance::createStreamDescriptorSurfaceGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo, 16849 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 16850 VULKAN_HPP_RAII_CREATE_NOEXCEPT 16851 { 16852 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 16853 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateStreamDescriptorSurfaceGGP( 16854 static_cast<VkInstance>( m_instance ), 16855 reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ), 16856 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 16857 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 16858 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 16859 { 16860 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 16861 return VULKAN_HPP_UNEXPECTED( result ); 16862 # else 16863 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createStreamDescriptorSurfaceGGP" ); 16864 # endif 16865 } 16866 16867 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 16868 } 16869 # endif /*VK_USE_PLATFORM_GGP*/ 16870 16871 //=== VK_NV_external_memory_capabilities === 16872 16873 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) const16874 PhysicalDevice::getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format, 16875 VULKAN_HPP_NAMESPACE::ImageType type, 16876 VULKAN_HPP_NAMESPACE::ImageTiling tiling, 16877 VULKAN_HPP_NAMESPACE::ImageUsageFlags usage, 16878 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags, 16879 VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType ) const 16880 { 16881 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV && 16882 "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> requires <VK_NV_external_memory_capabilities>" ); 16883 16884 VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties; 16885 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 16886 static_cast<VkPhysicalDevice>( m_physicalDevice ), 16887 static_cast<VkFormat>( format ), 16888 static_cast<VkImageType>( type ), 16889 static_cast<VkImageTiling>( tiling ), 16890 static_cast<VkImageUsageFlags>( usage ), 16891 static_cast<VkImageCreateFlags>( flags ), 16892 static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), 16893 reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) ); 16894 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); 16895 16896 return externalImageFormatProperties; 16897 } 16898 16899 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 16900 //=== VK_NV_external_memory_win32 === 16901 getMemoryWin32HandleNV(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType) const16902 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE DeviceMemory::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const 16903 { 16904 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleNV && "Function <vkGetMemoryWin32HandleNV> requires <VK_NV_external_memory_win32>" ); 16905 16906 HANDLE handle; 16907 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandleNV( 16908 static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) ); 16909 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" ); 16910 16911 return handle; 16912 } 16913 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 16914 16915 //=== VK_KHR_get_physical_device_properties2 === 16916 getFeatures2KHR() const16917 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT 16918 { 16919 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && 16920 "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 16921 16922 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features; 16923 getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 16924 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); 16925 16926 return features; 16927 } 16928 16929 template <typename X, typename Y, typename... Z> getFeatures2KHR() const16930 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT 16931 { 16932 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && 16933 "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 16934 16935 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 16936 VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>(); 16937 getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 16938 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) ); 16939 16940 return structureChain; 16941 } 16942 getProperties2KHR() const16943 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT 16944 { 16945 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2KHR && 16946 "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 16947 16948 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties; 16949 getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 16950 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); 16951 16952 return properties; 16953 } 16954 16955 template <typename X, typename Y, typename... Z> getProperties2KHR() const16956 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT 16957 { 16958 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2KHR && 16959 "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 16960 16961 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 16962 VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>(); 16963 getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 16964 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) ); 16965 16966 return structureChain; 16967 } 16968 16969 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format) const16970 PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 16971 { 16972 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && 16973 "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 16974 16975 VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties; 16976 getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( 16977 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); 16978 16979 return formatProperties; 16980 } 16981 16982 template <typename X, typename Y, typename... Z> 16983 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFormatProperties2KHR(VULKAN_HPP_NAMESPACE::Format format) const16984 PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT 16985 { 16986 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && 16987 "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 16988 16989 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 16990 VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>(); 16991 getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( 16992 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) ); 16993 16994 return structureChain; 16995 } 16996 16997 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2 getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo) const16998 PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const 16999 { 17000 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && 17001 "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 17002 17003 VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties; 17004 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17005 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17006 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), 17007 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); 17008 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); 17009 17010 return imageFormatProperties; 17011 } 17012 17013 template <typename X, typename Y, typename... Z> 17014 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo) const17015 PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const 17016 { 17017 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && 17018 "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 17019 17020 StructureChain<X, Y, Z...> structureChain; 17021 VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>(); 17022 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17023 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17024 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ), 17025 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) ); 17026 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); 17027 17028 return structureChain; 17029 } 17030 getQueueFamilyProperties2KHR() const17031 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> PhysicalDevice::getQueueFamilyProperties2KHR() const 17032 { 17033 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && 17034 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 17035 17036 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties; 17037 uint32_t queueFamilyPropertyCount; 17038 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 17039 queueFamilyProperties.resize( queueFamilyPropertyCount ); 17040 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17041 &queueFamilyPropertyCount, 17042 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); 17043 17044 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); 17045 if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) 17046 { 17047 queueFamilyProperties.resize( queueFamilyPropertyCount ); 17048 } 17049 return queueFamilyProperties; 17050 } 17051 17052 template <typename StructureChain> getQueueFamilyProperties2KHR() const17053 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2KHR() const 17054 { 17055 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && 17056 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 17057 17058 std::vector<StructureChain> structureChains; 17059 std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties; 17060 uint32_t queueFamilyPropertyCount; 17061 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); 17062 structureChains.resize( queueFamilyPropertyCount ); 17063 queueFamilyProperties.resize( queueFamilyPropertyCount ); 17064 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) 17065 { 17066 queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext; 17067 } 17068 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17069 &queueFamilyPropertyCount, 17070 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) ); 17071 17072 VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); 17073 if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) 17074 { 17075 structureChains.resize( queueFamilyPropertyCount ); 17076 } 17077 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) 17078 { 17079 structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i]; 17080 } 17081 return structureChains; 17082 } 17083 17084 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR() const17085 PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT 17086 { 17087 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && 17088 "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 17089 17090 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties; 17091 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17092 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); 17093 17094 return memoryProperties; 17095 } 17096 17097 template <typename X, typename Y, typename... Z> getMemoryProperties2KHR() const17098 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT 17099 { 17100 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && 17101 "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 17102 17103 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 17104 VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties = 17105 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>(); 17106 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17107 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) ); 17108 17109 return structureChain; 17110 } 17111 17112 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> getSparseImageFormatProperties2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo) const17113 PhysicalDevice::getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const 17114 { 17115 VULKAN_HPP_ASSERT( 17116 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR && 17117 "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" ); 17118 17119 std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties; 17120 uint32_t propertyCount; 17121 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17122 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), 17123 &propertyCount, 17124 nullptr ); 17125 properties.resize( propertyCount ); 17126 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17127 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ), 17128 &propertyCount, 17129 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) ); 17130 17131 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 17132 if ( propertyCount < properties.size() ) 17133 { 17134 properties.resize( propertyCount ); 17135 } 17136 return properties; 17137 } 17138 17139 //=== VK_KHR_device_group === 17140 17141 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex) const17142 Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT 17143 { 17144 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR && 17145 "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" ); 17146 17147 VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags peerMemoryFeatures; 17148 getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR( static_cast<VkDevice>( m_device ), 17149 heapIndex, 17150 localDeviceIndex, 17151 remoteDeviceIndex, 17152 reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) ); 17153 17154 return peerMemoryFeatures; 17155 } 17156 setDeviceMaskKHR(uint32_t deviceMask) const17157 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT 17158 { 17159 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMaskKHR && "Function <vkCmdSetDeviceMaskKHR> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" ); 17160 17161 getDispatcher()->vkCmdSetDeviceMaskKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask ); 17162 } 17163 dispatchBaseKHR(uint32_t baseGroupX,uint32_t baseGroupY,uint32_t baseGroupZ,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const17164 VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, 17165 uint32_t baseGroupY, 17166 uint32_t baseGroupZ, 17167 uint32_t groupCountX, 17168 uint32_t groupCountY, 17169 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 17170 { 17171 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBaseKHR && "Function <vkCmdDispatchBaseKHR> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" ); 17172 17173 getDispatcher()->vkCmdDispatchBaseKHR( 17174 static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); 17175 } 17176 17177 # if defined( VK_USE_PLATFORM_VI_NN ) 17178 //=== VK_NN_vi_surface === 17179 17180 VULKAN_HPP_NODISCARD 17181 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createViSurfaceNN(VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17182 Instance::createViSurfaceNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, 17183 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17184 VULKAN_HPP_RAII_CREATE_NOEXCEPT 17185 { 17186 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 17187 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateViSurfaceNN( 17188 static_cast<VkInstance>( m_instance ), 17189 reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ), 17190 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 17191 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 17192 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17193 { 17194 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 17195 return VULKAN_HPP_UNEXPECTED( result ); 17196 # else 17197 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createViSurfaceNN" ); 17198 # endif 17199 } 17200 17201 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 17202 } 17203 # endif /*VK_USE_PLATFORM_VI_NN*/ 17204 17205 //=== VK_KHR_maintenance1 === 17206 trimKHR(VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags) const17207 VULKAN_HPP_INLINE void CommandPool::trimKHR( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT 17208 { 17209 VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR && "Function <vkTrimCommandPoolKHR> requires <VK_KHR_maintenance1> or <VK_VERSION_1_1>" ); 17210 17211 getDispatcher()->vkTrimCommandPoolKHR( 17212 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) ); 17213 } 17214 17215 //=== VK_KHR_device_group_creation === 17216 enumeratePhysicalDeviceGroupsKHR() const17217 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> Instance::enumeratePhysicalDeviceGroupsKHR() const 17218 { 17219 VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR && 17220 "Function <vkEnumeratePhysicalDeviceGroupsKHR> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" ); 17221 17222 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties; 17223 uint32_t physicalDeviceGroupCount; 17224 VULKAN_HPP_NAMESPACE::Result result; 17225 do 17226 { 17227 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17228 getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) ); 17229 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount ) 17230 { 17231 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); 17232 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( 17233 static_cast<VkInstance>( m_instance ), 17234 &physicalDeviceGroupCount, 17235 reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) ); 17236 } 17237 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 17238 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); 17239 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); 17240 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) 17241 { 17242 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); 17243 } 17244 return physicalDeviceGroupProperties; 17245 } 17246 17247 //=== VK_KHR_external_memory_capabilities === 17248 getExternalBufferPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo) const17249 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR( 17250 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT 17251 { 17252 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR && 17253 "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" ); 17254 17255 VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties; 17256 getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17257 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ), 17258 reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) ); 17259 17260 return externalBufferProperties; 17261 } 17262 17263 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 17264 //=== VK_KHR_external_memory_win32 === 17265 17266 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE getMemoryWin32HandleKHR(const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo) const17267 Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const 17268 { 17269 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleKHR && "Function <vkGetMemoryWin32HandleKHR> requires <VK_KHR_external_memory_win32>" ); 17270 17271 HANDLE handle; 17272 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandleKHR( 17273 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) ); 17274 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); 17275 17276 return handle; 17277 } 17278 17279 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR getMemoryWin32HandlePropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,HANDLE handle) const17280 Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const 17281 { 17282 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR && 17283 "Function <vkGetMemoryWin32HandlePropertiesKHR> requires <VK_KHR_external_memory_win32>" ); 17284 17285 VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; 17286 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17287 getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR( static_cast<VkDevice>( m_device ), 17288 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), 17289 handle, 17290 reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) ); 17291 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); 17292 17293 return memoryWin32HandleProperties; 17294 } 17295 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 17296 17297 //=== VK_KHR_external_memory_fd === 17298 getMemoryFdKHR(const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo) const17299 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo ) const 17300 { 17301 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdKHR && "Function <vkGetMemoryFdKHR> requires <VK_KHR_external_memory_fd>" ); 17302 17303 int fd; 17304 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17305 getDispatcher()->vkGetMemoryFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) ); 17306 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); 17307 17308 return fd; 17309 } 17310 17311 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR getMemoryFdPropertiesKHR(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,int fd) const17312 Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd ) const 17313 { 17314 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdPropertiesKHR && "Function <vkGetMemoryFdPropertiesKHR> requires <VK_KHR_external_memory_fd>" ); 17315 17316 VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties; 17317 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17318 getDispatcher()->vkGetMemoryFdPropertiesKHR( static_cast<VkDevice>( m_device ), 17319 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), 17320 fd, 17321 reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) ); 17322 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); 17323 17324 return memoryFdProperties; 17325 } 17326 17327 //=== VK_KHR_external_semaphore_capabilities === 17328 getExternalSemaphorePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo) const17329 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( 17330 const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT 17331 { 17332 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR && 17333 "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" ); 17334 17335 VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties; 17336 getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 17337 static_cast<VkPhysicalDevice>( m_physicalDevice ), 17338 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ), 17339 reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) ); 17340 17341 return externalSemaphoreProperties; 17342 } 17343 17344 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 17345 //=== VK_KHR_external_semaphore_win32 === 17346 17347 VULKAN_HPP_INLINE void importSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo) const17348 Device::importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const 17349 { 17350 VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreWin32HandleKHR && 17351 "Function <vkImportSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" ); 17352 17353 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreWin32HandleKHR( 17354 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) ); 17355 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); 17356 } 17357 17358 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE getSemaphoreWin32HandleKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo) const17359 Device::getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const 17360 { 17361 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreWin32HandleKHR && 17362 "Function <vkGetSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" ); 17363 17364 HANDLE handle; 17365 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreWin32HandleKHR( 17366 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) ); 17367 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); 17368 17369 return handle; 17370 } 17371 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 17372 17373 //=== VK_KHR_external_semaphore_fd === 17374 importSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo) const17375 VULKAN_HPP_INLINE void Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const 17376 { 17377 VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreFdKHR && "Function <vkImportSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" ); 17378 17379 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreFdKHR( 17380 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) ); 17381 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); 17382 } 17383 getSemaphoreFdKHR(const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo) const17384 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo ) const 17385 { 17386 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreFdKHR && "Function <vkGetSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" ); 17387 17388 int fd; 17389 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17390 getDispatcher()->vkGetSemaphoreFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) ); 17391 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); 17392 17393 return fd; 17394 } 17395 17396 //=== VK_KHR_push_descriptor === 17397 pushDescriptorSetKHR(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t set,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites) const17398 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( 17399 VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 17400 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 17401 uint32_t set, 17402 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT 17403 { 17404 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetKHR && 17405 "Function <vkCmdPushDescriptorSetKHR> requires <VK_KHR_push_descriptor> or <VK_VERSION_1_4>" ); 17406 17407 getDispatcher()->vkCmdPushDescriptorSetKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17408 static_cast<VkPipelineBindPoint>( pipelineBindPoint ), 17409 static_cast<VkPipelineLayout>( layout ), 17410 set, 17411 descriptorWrites.size(), 17412 reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) ); 17413 } 17414 17415 template <typename DataType> pushDescriptorSetWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t set,DataType const & data) const17416 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 17417 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 17418 uint32_t set, 17419 DataType const & data ) const VULKAN_HPP_NOEXCEPT 17420 { 17421 VULKAN_HPP_ASSERT( 17422 getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR && 17423 "Function <vkCmdPushDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_KHR_push_descriptor> or <VK_VERSION_1_4>" ); 17424 17425 getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17426 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), 17427 static_cast<VkPipelineLayout>( layout ), 17428 set, 17429 reinterpret_cast<const void *>( &data ) ); 17430 } 17431 17432 //=== VK_EXT_conditional_rendering === 17433 beginConditionalRenderingEXT(const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin) const17434 VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( 17435 const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT 17436 { 17437 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginConditionalRenderingEXT && 17438 "Function <vkCmdBeginConditionalRenderingEXT> requires <VK_EXT_conditional_rendering>" ); 17439 17440 getDispatcher()->vkCmdBeginConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17441 reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) ); 17442 } 17443 endConditionalRenderingEXT() const17444 VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT 17445 { 17446 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndConditionalRenderingEXT && 17447 "Function <vkCmdEndConditionalRenderingEXT> requires <VK_EXT_conditional_rendering>" ); 17448 17449 getDispatcher()->vkCmdEndConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 17450 } 17451 17452 //=== VK_KHR_descriptor_update_template === 17453 17454 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 17455 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate>::Type createDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17456 Device::createDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo, 17457 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17458 VULKAN_HPP_RAII_CREATE_NOEXCEPT 17459 { 17460 VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; 17461 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDescriptorUpdateTemplateKHR( 17462 static_cast<VkDevice>( m_device ), 17463 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ), 17464 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 17465 reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) ); 17466 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17467 { 17468 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 17469 return VULKAN_HPP_UNEXPECTED( result ); 17470 # else 17471 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDescriptorUpdateTemplateKHR" ); 17472 # endif 17473 } 17474 17475 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( 17476 *this, *reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ), allocator ); 17477 } 17478 17479 VULKAN_HPP_INLINE void destroyDescriptorUpdateTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17480 Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 17481 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT 17482 { 17483 VULKAN_HPP_ASSERT( getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR && 17484 "Function <vkDestroyDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); 17485 17486 getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR( 17487 static_cast<VkDevice>( m_device ), 17488 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), 17489 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); 17490 } 17491 17492 template <typename DataType> updateWithTemplateKHR(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,DataType const & data) const17493 VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, 17494 DataType const & data ) const VULKAN_HPP_NOEXCEPT 17495 { 17496 VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR && 17497 "Function <vkUpdateDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" ); 17498 17499 getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR( static_cast<VkDevice>( m_device ), 17500 static_cast<VkDescriptorSet>( m_descriptorSet ), 17501 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), 17502 reinterpret_cast<const void *>( &data ) ); 17503 } 17504 17505 //=== VK_NV_clip_space_w_scaling === 17506 setViewportWScalingNV(uint32_t firstViewport,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings) const17507 VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( 17508 uint32_t firstViewport, 17509 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT 17510 { 17511 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWScalingNV && "Function <vkCmdSetViewportWScalingNV> requires <VK_NV_clip_space_w_scaling>" ); 17512 17513 getDispatcher()->vkCmdSetViewportWScalingNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 17514 firstViewport, 17515 viewportWScalings.size(), 17516 reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) ); 17517 } 17518 17519 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 17520 //=== VK_EXT_acquire_xlib_display === 17521 acquireXlibDisplayEXT(Display & dpy,VULKAN_HPP_NAMESPACE::DisplayKHR display) const17522 VULKAN_HPP_INLINE void PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const 17523 { 17524 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireXlibDisplayEXT && "Function <vkAcquireXlibDisplayEXT> requires <VK_EXT_acquire_xlib_display>" ); 17525 17526 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17527 getDispatcher()->vkAcquireXlibDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &dpy, static_cast<VkDisplayKHR>( display ) ) ); 17528 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); 17529 } 17530 17531 VULKAN_HPP_NODISCARD 17532 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type getRandROutputDisplayEXT(Display & dpy,RROutput rrOutput) const17533 PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 17534 { 17535 VULKAN_HPP_NAMESPACE::DisplayKHR display; 17536 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRandROutputDisplayEXT( 17537 static_cast<VkPhysicalDevice>( m_physicalDevice ), &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); 17538 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17539 { 17540 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 17541 return VULKAN_HPP_UNEXPECTED( result ); 17542 # else 17543 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::getRandROutputDisplayEXT" ); 17544 # endif 17545 } 17546 17547 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, *reinterpret_cast<VkDisplayKHR *>( &display ) ); 17548 } 17549 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 17550 17551 //=== VK_EXT_display_surface_counter === 17552 17553 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT getSurfaceCapabilities2EXT(VULKAN_HPP_NAMESPACE::SurfaceKHR surface) const17554 PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const 17555 { 17556 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT && 17557 "Function <vkGetPhysicalDeviceSurfaceCapabilities2EXT> requires <VK_EXT_display_surface_counter>" ); 17558 17559 VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities; 17560 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17561 getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17562 static_cast<VkSurfaceKHR>( surface ), 17563 reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) ) ); 17564 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); 17565 17566 return surfaceCapabilities; 17567 } 17568 17569 //=== VK_EXT_display_control === 17570 displayPowerControlEXT(VULKAN_HPP_NAMESPACE::DisplayKHR display,const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo) const17571 VULKAN_HPP_INLINE void Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, 17572 const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo ) const 17573 { 17574 VULKAN_HPP_ASSERT( getDispatcher()->vkDisplayPowerControlEXT && "Function <vkDisplayPowerControlEXT> requires <VK_EXT_display_control>" ); 17575 17576 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDisplayPowerControlEXT( 17577 static_cast<VkDevice>( m_device ), static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) ); 17578 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); 17579 } 17580 17581 VULKAN_HPP_NODISCARD 17582 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type registerEventEXT(VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17583 Device::registerEventEXT( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo, 17584 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17585 VULKAN_HPP_RAII_CREATE_NOEXCEPT 17586 { 17587 VULKAN_HPP_NAMESPACE::Fence fence; 17588 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkRegisterDeviceEventEXT( 17589 static_cast<VkDevice>( m_device ), 17590 reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ), 17591 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 17592 reinterpret_cast<VkFence *>( &fence ) ) ); 17593 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17594 { 17595 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 17596 return VULKAN_HPP_UNEXPECTED( result ); 17597 # else 17598 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::registerEventEXT" ); 17599 # endif 17600 } 17601 17602 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence( *this, *reinterpret_cast<VkFence *>( &fence ), allocator ); 17603 } 17604 17605 VULKAN_HPP_NODISCARD 17606 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type 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) const17607 Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, 17608 VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo, 17609 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17610 VULKAN_HPP_RAII_CREATE_NOEXCEPT 17611 { 17612 VULKAN_HPP_NAMESPACE::Fence fence; 17613 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkRegisterDisplayEventEXT( 17614 static_cast<VkDevice>( m_device ), 17615 static_cast<VkDisplayKHR>( *display ), 17616 reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ), 17617 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 17618 reinterpret_cast<VkFence *>( &fence ) ) ); 17619 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17620 { 17621 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 17622 return VULKAN_HPP_UNEXPECTED( result ); 17623 # else 17624 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::registerDisplayEventEXT" ); 17625 # endif 17626 } 17627 17628 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence( *this, *reinterpret_cast<VkFence *>( &fence ), allocator ); 17629 } 17630 getCounterEXT(VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter) const17631 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t SwapchainKHR::getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const 17632 { 17633 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainCounterEXT && "Function <vkGetSwapchainCounterEXT> requires <VK_EXT_display_control>" ); 17634 17635 uint64_t counterValue; 17636 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainCounterEXT( 17637 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) ); 17638 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" ); 17639 17640 return counterValue; 17641 } 17642 17643 //=== VK_GOOGLE_display_timing === 17644 getRefreshCycleDurationGOOGLE() const17645 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE SwapchainKHR::getRefreshCycleDurationGOOGLE() const 17646 { 17647 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRefreshCycleDurationGOOGLE && "Function <vkGetRefreshCycleDurationGOOGLE> requires <VK_GOOGLE_display_timing>" ); 17648 17649 VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties; 17650 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17651 getDispatcher()->vkGetRefreshCycleDurationGOOGLE( static_cast<VkDevice>( m_device ), 17652 static_cast<VkSwapchainKHR>( m_swapchain ), 17653 reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) ); 17654 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" ); 17655 17656 return displayTimingProperties; 17657 } 17658 getPastPresentationTimingGOOGLE() const17659 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> SwapchainKHR::getPastPresentationTimingGOOGLE() const 17660 { 17661 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPastPresentationTimingGOOGLE && 17662 "Function <vkGetPastPresentationTimingGOOGLE> requires <VK_GOOGLE_display_timing>" ); 17663 17664 std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> presentationTimings; 17665 uint32_t presentationTimingCount; 17666 VULKAN_HPP_NAMESPACE::Result result; 17667 do 17668 { 17669 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPastPresentationTimingGOOGLE( 17670 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), &presentationTimingCount, nullptr ) ); 17671 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount ) 17672 { 17673 presentationTimings.resize( presentationTimingCount ); 17674 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17675 getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast<VkDevice>( m_device ), 17676 static_cast<VkSwapchainKHR>( m_swapchain ), 17677 &presentationTimingCount, 17678 reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) ); 17679 } 17680 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 17681 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE" ); 17682 VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); 17683 if ( presentationTimingCount < presentationTimings.size() ) 17684 { 17685 presentationTimings.resize( presentationTimingCount ); 17686 } 17687 return presentationTimings; 17688 } 17689 17690 //=== VK_EXT_discard_rectangles === 17691 setDiscardRectangleEXT(uint32_t firstDiscardRectangle,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles) const17692 VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( 17693 uint32_t firstDiscardRectangle, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT 17694 { 17695 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleEXT && "Function <vkCmdSetDiscardRectangleEXT> requires <VK_EXT_discard_rectangles>" ); 17696 17697 getDispatcher()->vkCmdSetDiscardRectangleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17698 firstDiscardRectangle, 17699 discardRectangles.size(), 17700 reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) ); 17701 } 17702 setDiscardRectangleEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable) const17703 VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT 17704 { 17705 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleEnableEXT && 17706 "Function <vkCmdSetDiscardRectangleEnableEXT> requires <VK_EXT_discard_rectangles>" ); 17707 17708 getDispatcher()->vkCmdSetDiscardRectangleEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( discardRectangleEnable ) ); 17709 } 17710 17711 VULKAN_HPP_INLINE void setDiscardRectangleModeEXT(VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode) const17712 CommandBuffer::setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT 17713 { 17714 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleModeEXT && 17715 "Function <vkCmdSetDiscardRectangleModeEXT> requires <VK_EXT_discard_rectangles>" ); 17716 17717 getDispatcher()->vkCmdSetDiscardRectangleModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 17718 static_cast<VkDiscardRectangleModeEXT>( discardRectangleMode ) ); 17719 } 17720 17721 //=== VK_EXT_hdr_metadata === 17722 setHdrMetadataEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata) const17723 VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains, 17724 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const 17725 { 17726 VULKAN_HPP_ASSERT( getDispatcher()->vkSetHdrMetadataEXT && "Function <vkSetHdrMetadataEXT> requires <VK_EXT_hdr_metadata>" ); 17727 # ifdef VULKAN_HPP_NO_EXCEPTIONS 17728 VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); 17729 # else 17730 if ( swapchains.size() != metadata.size() ) 17731 { 17732 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); 17733 } 17734 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 17735 17736 getDispatcher()->vkSetHdrMetadataEXT( static_cast<VkDevice>( m_device ), 17737 swapchains.size(), 17738 reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ), 17739 reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) ); 17740 } 17741 17742 //=== VK_KHR_create_renderpass2 === 17743 17744 VULKAN_HPP_NODISCARD 17745 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type createRenderPass2KHR(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const17746 Device::createRenderPass2KHR( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo, 17747 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 17748 VULKAN_HPP_RAII_CREATE_NOEXCEPT 17749 { 17750 VULKAN_HPP_NAMESPACE::RenderPass renderPass; 17751 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRenderPass2KHR( 17752 static_cast<VkDevice>( m_device ), 17753 reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ), 17754 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 17755 reinterpret_cast<VkRenderPass *>( &renderPass ) ) ); 17756 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 17757 { 17758 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 17759 return VULKAN_HPP_UNEXPECTED( result ); 17760 # else 17761 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRenderPass2KHR" ); 17762 # endif 17763 } 17764 17765 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, *reinterpret_cast<VkRenderPass *>( &renderPass ), allocator ); 17766 } 17767 beginRenderPass2KHR(const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo) const17768 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin, 17769 const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 17770 { 17771 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2KHR && 17772 "Function <vkCmdBeginRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); 17773 17774 getDispatcher()->vkCmdBeginRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17775 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ), 17776 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) ); 17777 } 17778 nextSubpass2KHR(const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo) const17779 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo, 17780 const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 17781 { 17782 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2KHR && "Function <vkCmdNextSubpass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); 17783 17784 getDispatcher()->vkCmdNextSubpass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 17785 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ), 17786 reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); 17787 } 17788 endRenderPass2KHR(const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo) const17789 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT 17790 { 17791 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2KHR && 17792 "Function <vkCmdEndRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" ); 17793 17794 getDispatcher()->vkCmdEndRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) ); 17795 } 17796 17797 //=== VK_KHR_shared_presentable_image === 17798 getStatus() const17799 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result SwapchainKHR::getStatus() const 17800 { 17801 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainStatusKHR && "Function <vkGetSwapchainStatusKHR> requires <VK_KHR_shared_presentable_image>" ); 17802 17803 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17804 getDispatcher()->vkGetSwapchainStatusKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) ); 17805 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 17806 VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus", 17807 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); 17808 17809 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 17810 } 17811 17812 //=== VK_KHR_external_fence_capabilities === 17813 17814 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo) const17815 PhysicalDevice::getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT 17816 { 17817 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR && 17818 "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" ); 17819 17820 VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties; 17821 getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17822 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ), 17823 reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) ); 17824 17825 return externalFenceProperties; 17826 } 17827 17828 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 17829 //=== VK_KHR_external_fence_win32 === 17830 importFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo) const17831 VULKAN_HPP_INLINE void Device::importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const 17832 { 17833 VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceWin32HandleKHR && "Function <vkImportFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" ); 17834 17835 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportFenceWin32HandleKHR( 17836 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) ); 17837 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); 17838 } 17839 17840 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE getFenceWin32HandleKHR(const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo) const17841 Device::getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const 17842 { 17843 VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceWin32HandleKHR && "Function <vkGetFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" ); 17844 17845 HANDLE handle; 17846 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceWin32HandleKHR( 17847 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) ); 17848 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); 17849 17850 return handle; 17851 } 17852 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 17853 17854 //=== VK_KHR_external_fence_fd === 17855 importFenceFdKHR(const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo) const17856 VULKAN_HPP_INLINE void Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo ) const 17857 { 17858 VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceFdKHR && "Function <vkImportFenceFdKHR> requires <VK_KHR_external_fence_fd>" ); 17859 17860 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17861 getDispatcher()->vkImportFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) ); 17862 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" ); 17863 } 17864 getFenceFdKHR(const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo) const17865 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo ) const 17866 { 17867 VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceFdKHR && "Function <vkGetFenceFdKHR> requires <VK_KHR_external_fence_fd>" ); 17868 17869 int fd; 17870 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17871 getDispatcher()->vkGetFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) ); 17872 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); 17873 17874 return fd; 17875 } 17876 17877 //=== VK_KHR_performance_query === 17878 17879 VULKAN_HPP_NODISCARD 17880 VULKAN_HPP_INLINE std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>> enumerateQueueFamilyPerformanceQueryCountersKHR(uint32_t queueFamilyIndex) const17881 PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const 17882 { 17883 VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && 17884 "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" ); 17885 17886 std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>> data_; 17887 std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> & counters = data_.first; 17888 std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> & counterDescriptions = data_.second; 17889 uint32_t counterCount; 17890 VULKAN_HPP_NAMESPACE::Result result; 17891 do 17892 { 17893 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 17894 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr ) ); 17895 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && counterCount ) 17896 { 17897 counters.resize( counterCount ); 17898 counterDescriptions.resize( counterCount ); 17899 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 17900 static_cast<VkPhysicalDevice>( m_physicalDevice ), 17901 queueFamilyIndex, 17902 &counterCount, 17903 reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ), 17904 reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) ); 17905 } 17906 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 17907 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); 17908 VULKAN_HPP_ASSERT( counterCount <= counters.size() ); 17909 if ( counterCount < counters.size() ) 17910 { 17911 counters.resize( counterCount ); 17912 counterDescriptions.resize( counterCount ); 17913 } 17914 return data_; 17915 } 17916 getQueueFamilyPerformanceQueryPassesKHR(const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo) const17917 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( 17918 const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT 17919 { 17920 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR && 17921 "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> requires <VK_KHR_performance_query>" ); 17922 17923 uint32_t numPasses; 17924 getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( 17925 static_cast<VkPhysicalDevice>( m_physicalDevice ), 17926 reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ), 17927 &numPasses ); 17928 17929 return numPasses; 17930 } 17931 acquireProfilingLockKHR(const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info) const17932 VULKAN_HPP_INLINE void Device::acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info ) const 17933 { 17934 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireProfilingLockKHR && "Function <vkAcquireProfilingLockKHR> requires <VK_KHR_performance_query>" ); 17935 17936 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17937 getDispatcher()->vkAcquireProfilingLockKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) ); 17938 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); 17939 } 17940 releaseProfilingLockKHR() const17941 VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT 17942 { 17943 VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseProfilingLockKHR && "Function <vkReleaseProfilingLockKHR> requires <VK_KHR_performance_query>" ); 17944 17945 getDispatcher()->vkReleaseProfilingLockKHR( static_cast<VkDevice>( m_device ) ); 17946 } 17947 17948 //=== VK_KHR_get_surface_capabilities2 === 17949 17950 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const17951 PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 17952 { 17953 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && 17954 "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" ); 17955 17956 VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities; 17957 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17958 getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17959 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 17960 reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) ); 17961 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); 17962 17963 return surfaceCapabilities; 17964 } 17965 17966 template <typename X, typename Y, typename... Z> 17967 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getSurfaceCapabilities2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const17968 PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 17969 { 17970 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && 17971 "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" ); 17972 17973 StructureChain<X, Y, Z...> structureChain; 17974 VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>(); 17975 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17976 getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17977 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 17978 reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) ); 17979 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); 17980 17981 return structureChain; 17982 } 17983 17984 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> getSurfaceFormats2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const17985 PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 17986 { 17987 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR && 17988 "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" ); 17989 17990 std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats; 17991 uint32_t surfaceFormatCount; 17992 VULKAN_HPP_NAMESPACE::Result result; 17993 do 17994 { 17995 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 17996 getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 17997 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 17998 &surfaceFormatCount, 17999 nullptr ) ); 18000 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) 18001 { 18002 surfaceFormats.resize( surfaceFormatCount ); 18003 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18004 getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 18005 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 18006 &surfaceFormatCount, 18007 reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) ); 18008 } 18009 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 18010 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); 18011 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); 18012 if ( surfaceFormatCount < surfaceFormats.size() ) 18013 { 18014 surfaceFormats.resize( surfaceFormatCount ); 18015 } 18016 return surfaceFormats; 18017 } 18018 18019 template <typename StructureChain> 18020 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> getSurfaceFormats2KHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const18021 PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 18022 { 18023 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR && 18024 "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" ); 18025 18026 std::vector<StructureChain> structureChains; 18027 std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats; 18028 uint32_t surfaceFormatCount; 18029 VULKAN_HPP_NAMESPACE::Result result; 18030 do 18031 { 18032 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18033 getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 18034 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 18035 &surfaceFormatCount, 18036 nullptr ) ); 18037 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount ) 18038 { 18039 structureChains.resize( surfaceFormatCount ); 18040 surfaceFormats.resize( surfaceFormatCount ); 18041 for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) 18042 { 18043 surfaceFormats[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>().pNext; 18044 } 18045 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18046 getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 18047 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 18048 &surfaceFormatCount, 18049 reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) ); 18050 } 18051 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 18052 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); 18053 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); 18054 if ( surfaceFormatCount < surfaceFormats.size() ) 18055 { 18056 structureChains.resize( surfaceFormatCount ); 18057 } 18058 for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) 18059 { 18060 structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>() = surfaceFormats[i]; 18061 } 18062 return structureChains; 18063 } 18064 18065 //=== VK_KHR_get_display_properties2 === 18066 getDisplayProperties2KHR() const18067 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> PhysicalDevice::getDisplayProperties2KHR() const 18068 { 18069 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR && 18070 "Function <vkGetPhysicalDeviceDisplayProperties2KHR> requires <VK_KHR_get_display_properties2>" ); 18071 18072 std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> properties; 18073 uint32_t propertyCount; 18074 VULKAN_HPP_NAMESPACE::Result result; 18075 do 18076 { 18077 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18078 getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 18079 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 18080 { 18081 properties.resize( propertyCount ); 18082 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( 18083 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) ); 18084 } 18085 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 18086 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); 18087 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 18088 if ( propertyCount < properties.size() ) 18089 { 18090 properties.resize( propertyCount ); 18091 } 18092 return properties; 18093 } 18094 getDisplayPlaneProperties2KHR() const18095 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> PhysicalDevice::getDisplayPlaneProperties2KHR() const 18096 { 18097 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR && 18098 "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> requires <VK_KHR_get_display_properties2>" ); 18099 18100 std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> properties; 18101 uint32_t propertyCount; 18102 VULKAN_HPP_NAMESPACE::Result result; 18103 do 18104 { 18105 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18106 getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 18107 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 18108 { 18109 properties.resize( propertyCount ); 18110 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( 18111 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) ); 18112 } 18113 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 18114 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); 18115 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 18116 if ( propertyCount < properties.size() ) 18117 { 18118 properties.resize( propertyCount ); 18119 } 18120 return properties; 18121 } 18122 getModeProperties2() const18123 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> DisplayKHR::getModeProperties2() const 18124 { 18125 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModeProperties2KHR && 18126 "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" ); 18127 18128 std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> properties; 18129 uint32_t propertyCount; 18130 VULKAN_HPP_NAMESPACE::Result result; 18131 do 18132 { 18133 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModeProperties2KHR( 18134 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ), &propertyCount, nullptr ) ); 18135 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 18136 { 18137 properties.resize( propertyCount ); 18138 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18139 getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 18140 static_cast<VkDisplayKHR>( m_display ), 18141 &propertyCount, 18142 reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) ); 18143 } 18144 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 18145 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" ); 18146 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 18147 if ( propertyCount < properties.size() ) 18148 { 18149 properties.resize( propertyCount ); 18150 } 18151 return properties; 18152 } 18153 18154 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR getDisplayPlaneCapabilities2KHR(const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo) const18155 PhysicalDevice::getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const 18156 { 18157 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilities2KHR && 18158 "Function <vkGetDisplayPlaneCapabilities2KHR> requires <VK_KHR_get_display_properties2>" ); 18159 18160 VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities; 18161 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18162 getDispatcher()->vkGetDisplayPlaneCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), 18163 reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ), 18164 reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) ); 18165 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); 18166 18167 return capabilities; 18168 } 18169 18170 # if defined( VK_USE_PLATFORM_IOS_MVK ) 18171 //=== VK_MVK_ios_surface === 18172 18173 VULKAN_HPP_NODISCARD 18174 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createIOSSurfaceMVK(VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const18175 Instance::createIOSSurfaceMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo, 18176 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 18177 VULKAN_HPP_RAII_CREATE_NOEXCEPT 18178 { 18179 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 18180 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateIOSSurfaceMVK( 18181 static_cast<VkInstance>( m_instance ), 18182 reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ), 18183 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 18184 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 18185 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 18186 { 18187 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 18188 return VULKAN_HPP_UNEXPECTED( result ); 18189 # else 18190 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createIOSSurfaceMVK" ); 18191 # endif 18192 } 18193 18194 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 18195 } 18196 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 18197 18198 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 18199 //=== VK_MVK_macos_surface === 18200 18201 VULKAN_HPP_NODISCARD 18202 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createMacOSSurfaceMVK(VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const18203 Instance::createMacOSSurfaceMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo, 18204 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 18205 VULKAN_HPP_RAII_CREATE_NOEXCEPT 18206 { 18207 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 18208 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateMacOSSurfaceMVK( 18209 static_cast<VkInstance>( m_instance ), 18210 reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ), 18211 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 18212 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 18213 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 18214 { 18215 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 18216 return VULKAN_HPP_UNEXPECTED( result ); 18217 # else 18218 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createMacOSSurfaceMVK" ); 18219 # endif 18220 } 18221 18222 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 18223 } 18224 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 18225 18226 //=== VK_EXT_debug_utils === 18227 setDebugUtilsObjectNameEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo) const18228 VULKAN_HPP_INLINE void Device::setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo ) const 18229 { 18230 VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectNameEXT && "Function <vkSetDebugUtilsObjectNameEXT> requires <VK_EXT_debug_utils>" ); 18231 18232 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetDebugUtilsObjectNameEXT( 18233 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) ); 18234 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); 18235 } 18236 setDebugUtilsObjectTagEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo) const18237 VULKAN_HPP_INLINE void Device::setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo ) const 18238 { 18239 VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectTagEXT && "Function <vkSetDebugUtilsObjectTagEXT> requires <VK_EXT_debug_utils>" ); 18240 18241 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18242 getDispatcher()->vkSetDebugUtilsObjectTagEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) ); 18243 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); 18244 } 18245 beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo) const18246 VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT 18247 { 18248 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBeginDebugUtilsLabelEXT && "Function <vkQueueBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); 18249 18250 getDispatcher()->vkQueueBeginDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); 18251 } 18252 endDebugUtilsLabelEXT() const18253 VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT 18254 { 18255 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueEndDebugUtilsLabelEXT && "Function <vkQueueEndDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); 18256 18257 getDispatcher()->vkQueueEndDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ) ); 18258 } 18259 insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo) const18260 VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT 18261 { 18262 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueInsertDebugUtilsLabelEXT && "Function <vkQueueInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); 18263 18264 getDispatcher()->vkQueueInsertDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); 18265 } 18266 beginDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo) const18267 VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT 18268 { 18269 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginDebugUtilsLabelEXT && "Function <vkCmdBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); 18270 18271 getDispatcher()->vkCmdBeginDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 18272 reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); 18273 } 18274 endDebugUtilsLabelEXT() const18275 VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT 18276 { 18277 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndDebugUtilsLabelEXT && "Function <vkCmdEndDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); 18278 18279 getDispatcher()->vkCmdEndDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 18280 } 18281 insertDebugUtilsLabelEXT(const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo) const18282 VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT 18283 { 18284 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInsertDebugUtilsLabelEXT && "Function <vkCmdInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" ); 18285 18286 getDispatcher()->vkCmdInsertDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 18287 reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) ); 18288 } 18289 18290 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 18291 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT>::Type createDebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const18292 Instance::createDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo, 18293 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 18294 VULKAN_HPP_RAII_CREATE_NOEXCEPT 18295 { 18296 VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger; 18297 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDebugUtilsMessengerEXT( 18298 static_cast<VkInstance>( m_instance ), 18299 reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ), 18300 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 18301 reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) ); 18302 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 18303 { 18304 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 18305 return VULKAN_HPP_UNEXPECTED( result ); 18306 # else 18307 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createDebugUtilsMessengerEXT" ); 18308 # endif 18309 } 18310 18311 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT( 18312 *this, *reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ), allocator ); 18313 } 18314 18315 VULKAN_HPP_INLINE void submitDebugUtilsMessageEXT(VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes,const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData) const18316 Instance::submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 18317 VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes, 18318 const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT 18319 { 18320 VULKAN_HPP_ASSERT( getDispatcher()->vkSubmitDebugUtilsMessageEXT && "Function <vkSubmitDebugUtilsMessageEXT> requires <VK_EXT_debug_utils>" ); 18321 18322 getDispatcher()->vkSubmitDebugUtilsMessageEXT( static_cast<VkInstance>( m_instance ), 18323 static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), 18324 static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), 18325 reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) ); 18326 } 18327 18328 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 18329 //=== VK_ANDROID_external_memory_android_hardware_buffer === 18330 18331 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer & buffer) const18332 Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const 18333 { 18334 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && 18335 "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" ); 18336 18337 VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties; 18338 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( 18339 static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) ); 18340 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); 18341 18342 return properties; 18343 } 18344 18345 template <typename X, typename Y, typename... Z> 18346 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer & buffer) const18347 Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const 18348 { 18349 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && 18350 "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" ); 18351 18352 StructureChain<X, Y, Z...> structureChain; 18353 VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties = 18354 structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>(); 18355 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( 18356 static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) ); 18357 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); 18358 18359 return structureChain; 18360 } 18361 18362 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE struct AHardwareBuffer * getMemoryAndroidHardwareBufferANDROID(const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info) const18363 Device::getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info ) const 18364 { 18365 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID && 18366 "Function <vkGetMemoryAndroidHardwareBufferANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" ); 18367 18368 struct AHardwareBuffer * buffer; 18369 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID( 18370 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer ) ); 18371 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); 18372 18373 return buffer; 18374 } 18375 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 18376 18377 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 18378 //=== VK_AMDX_shader_enqueue === 18379 18380 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 18381 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type createExecutionGraphPipelinesAMDX(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const18382 Device::createExecutionGraphPipelinesAMDX( 18383 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 18384 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos, 18385 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 18386 { 18387 std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); 18388 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateExecutionGraphPipelinesAMDX( 18389 static_cast<VkDevice>( m_device ), 18390 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 18391 createInfos.size(), 18392 reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ), 18393 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 18394 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); 18395 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 18396 { 18397 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 18398 return VULKAN_HPP_UNEXPECTED( result ); 18399 # else 18400 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createExecutionGraphPipelinesAMDX" ); 18401 # endif 18402 } 18403 18404 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII; 18405 pipelinesRAII.reserve( pipelines.size() ); 18406 for ( auto & pipeline : pipelines ) 18407 { 18408 pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 18409 } 18410 return pipelinesRAII; 18411 } 18412 18413 VULKAN_HPP_NODISCARD 18414 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type createExecutionGraphPipelineAMDX(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const18415 Device::createExecutionGraphPipelineAMDX( 18416 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 18417 VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & createInfo, 18418 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 18419 { 18420 VULKAN_HPP_NAMESPACE::Pipeline pipeline; 18421 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateExecutionGraphPipelinesAMDX( 18422 static_cast<VkDevice>( m_device ), 18423 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 18424 1, 18425 reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( &createInfo ), 18426 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 18427 reinterpret_cast<VkPipeline *>( &pipeline ) ) ); 18428 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 18429 { 18430 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 18431 return VULKAN_HPP_UNEXPECTED( result ); 18432 # else 18433 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createExecutionGraphPipelineAMDX" ); 18434 # endif 18435 } 18436 18437 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 18438 } 18439 getExecutionGraphScratchSizeAMDX() const18440 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX Pipeline::getExecutionGraphScratchSizeAMDX() const 18441 { 18442 VULKAN_HPP_ASSERT( getDispatcher()->vkGetExecutionGraphPipelineScratchSizeAMDX && 18443 "Function <vkGetExecutionGraphPipelineScratchSizeAMDX> requires <VK_AMDX_shader_enqueue>" ); 18444 18445 VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX sizeInfo; 18446 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetExecutionGraphPipelineScratchSizeAMDX( 18447 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX *>( &sizeInfo ) ) ); 18448 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getExecutionGraphScratchSizeAMDX" ); 18449 18450 return sizeInfo; 18451 } 18452 18453 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t getExecutionGraphNodeIndexAMDX(const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo) const18454 Pipeline::getExecutionGraphNodeIndexAMDX( const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo ) const 18455 { 18456 VULKAN_HPP_ASSERT( getDispatcher()->vkGetExecutionGraphPipelineNodeIndexAMDX && 18457 "Function <vkGetExecutionGraphPipelineNodeIndexAMDX> requires <VK_AMDX_shader_enqueue>" ); 18458 18459 uint32_t nodeIndex; 18460 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18461 getDispatcher()->vkGetExecutionGraphPipelineNodeIndexAMDX( static_cast<VkDevice>( m_device ), 18462 static_cast<VkPipeline>( m_pipeline ), 18463 reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>( &nodeInfo ), 18464 &nodeIndex ) ); 18465 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getExecutionGraphNodeIndexAMDX" ); 18466 18467 return nodeIndex; 18468 } 18469 initializeGraphScratchMemoryAMDX(VULKAN_HPP_NAMESPACE::DeviceAddress scratch) const18470 VULKAN_HPP_INLINE void CommandBuffer::initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch ) const VULKAN_HPP_NOEXCEPT 18471 { 18472 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInitializeGraphScratchMemoryAMDX && 18473 "Function <vkCmdInitializeGraphScratchMemoryAMDX> requires <VK_AMDX_shader_enqueue>" ); 18474 18475 getDispatcher()->vkCmdInitializeGraphScratchMemoryAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( scratch ) ); 18476 } 18477 dispatchGraphAMDX(VULKAN_HPP_NAMESPACE::DeviceAddress scratch,const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo) const18478 VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, 18479 const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT 18480 { 18481 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphAMDX && "Function <vkCmdDispatchGraphAMDX> requires <VK_AMDX_shader_enqueue>" ); 18482 18483 getDispatcher()->vkCmdDispatchGraphAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ), 18484 static_cast<VkDeviceAddress>( scratch ), 18485 reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) ); 18486 } 18487 18488 VULKAN_HPP_INLINE void dispatchGraphIndirectAMDX(VULKAN_HPP_NAMESPACE::DeviceAddress scratch,const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo) const18489 CommandBuffer::dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, 18490 const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT 18491 { 18492 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphIndirectAMDX && "Function <vkCmdDispatchGraphIndirectAMDX> requires <VK_AMDX_shader_enqueue>" ); 18493 18494 getDispatcher()->vkCmdDispatchGraphIndirectAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ), 18495 static_cast<VkDeviceAddress>( scratch ), 18496 reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) ); 18497 } 18498 dispatchGraphIndirectCountAMDX(VULKAN_HPP_NAMESPACE::DeviceAddress scratch,VULKAN_HPP_NAMESPACE::DeviceAddress countInfo) const18499 VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch, 18500 VULKAN_HPP_NAMESPACE::DeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT 18501 { 18502 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphIndirectCountAMDX && 18503 "Function <vkCmdDispatchGraphIndirectCountAMDX> requires <VK_AMDX_shader_enqueue>" ); 18504 18505 getDispatcher()->vkCmdDispatchGraphIndirectCountAMDX( 18506 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( scratch ), static_cast<VkDeviceAddress>( countInfo ) ); 18507 } 18508 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 18509 18510 //=== VK_EXT_sample_locations === 18511 18512 VULKAN_HPP_INLINE void setSampleLocationsEXT(const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo) const18513 CommandBuffer::setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT 18514 { 18515 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEXT && "Function <vkCmdSetSampleLocationsEXT> requires <VK_EXT_sample_locations>" ); 18516 18517 getDispatcher()->vkCmdSetSampleLocationsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 18518 reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) ); 18519 } 18520 18521 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples) const18522 PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT 18523 { 18524 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT && 18525 "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> requires <VK_EXT_sample_locations>" ); 18526 18527 VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties; 18528 getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), 18529 static_cast<VkSampleCountFlagBits>( samples ), 18530 reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) ); 18531 18532 return multisampleProperties; 18533 } 18534 18535 //=== VK_KHR_get_memory_requirements2 === 18536 18537 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info) const18538 Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 18539 { 18540 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2KHR && 18541 "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 18542 18543 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 18544 getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast<VkDevice>( m_device ), 18545 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), 18546 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 18547 18548 return memoryRequirements; 18549 } 18550 18551 template <typename X, typename Y, typename... Z> 18552 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info) const18553 Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 18554 { 18555 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2KHR && 18556 "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 18557 18558 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 18559 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 18560 getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast<VkDevice>( m_device ), 18561 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ), 18562 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 18563 18564 return structureChain; 18565 } 18566 18567 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info) const18568 Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 18569 { 18570 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2KHR && 18571 "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 18572 18573 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 18574 getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast<VkDevice>( m_device ), 18575 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), 18576 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 18577 18578 return memoryRequirements; 18579 } 18580 18581 template <typename X, typename Y, typename... Z> 18582 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info) const18583 Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT 18584 { 18585 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2KHR && 18586 "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 18587 18588 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 18589 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 18590 getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast<VkDevice>( m_device ), 18591 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ), 18592 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 18593 18594 return structureChain; 18595 } 18596 18597 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> getImageSparseMemoryRequirements2KHR(const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info) const18598 Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const 18599 { 18600 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements2KHR && 18601 "Function <vkGetImageSparseMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" ); 18602 18603 std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements; 18604 uint32_t sparseMemoryRequirementCount; 18605 getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( 18606 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr ); 18607 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 18608 getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( static_cast<VkDevice>( m_device ), 18609 reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), 18610 &sparseMemoryRequirementCount, 18611 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); 18612 18613 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); 18614 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) 18615 { 18616 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 18617 } 18618 return sparseMemoryRequirements; 18619 } 18620 18621 //=== VK_KHR_acceleration_structure === 18622 18623 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 18624 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR>::Type createAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const18625 Device::createAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo, 18626 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 18627 VULKAN_HPP_RAII_CREATE_NOEXCEPT 18628 { 18629 VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; 18630 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateAccelerationStructureKHR( 18631 static_cast<VkDevice>( m_device ), 18632 reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ), 18633 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 18634 reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) ); 18635 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 18636 { 18637 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 18638 return VULKAN_HPP_UNEXPECTED( result ); 18639 # else 18640 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createAccelerationStructureKHR" ); 18641 # endif 18642 } 18643 18644 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR( 18645 *this, *reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ), allocator ); 18646 } 18647 buildAccelerationStructuresKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos) const18648 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( 18649 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 18650 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) const 18651 { 18652 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructuresKHR && 18653 "Function <vkCmdBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" ); 18654 # ifdef VULKAN_HPP_NO_EXCEPTIONS 18655 VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); 18656 # else 18657 if ( infos.size() != pBuildRangeInfos.size() ) 18658 { 18659 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); 18660 } 18661 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 18662 18663 getDispatcher()->vkCmdBuildAccelerationStructuresKHR( 18664 static_cast<VkCommandBuffer>( m_commandBuffer ), 18665 infos.size(), 18666 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), 18667 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ); 18668 } 18669 buildAccelerationStructuresIndirectKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses,VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides,VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts) const18670 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( 18671 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 18672 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses, 18673 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides, 18674 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const 18675 { 18676 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR && 18677 "Function <vkCmdBuildAccelerationStructuresIndirectKHR> requires <VK_KHR_acceleration_structure>" ); 18678 # ifdef VULKAN_HPP_NO_EXCEPTIONS 18679 VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() ); 18680 VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() ); 18681 VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() ); 18682 # else 18683 if ( infos.size() != indirectDeviceAddresses.size() ) 18684 { 18685 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 18686 "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" ); 18687 } 18688 if ( infos.size() != indirectStrides.size() ) 18689 { 18690 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" ); 18691 } 18692 if ( infos.size() != pMaxPrimitiveCounts.size() ) 18693 { 18694 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" ); 18695 } 18696 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 18697 18698 getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 18699 infos.size(), 18700 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), 18701 reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ), 18702 indirectStrides.data(), 18703 pMaxPrimitiveCounts.data() ); 18704 } 18705 buildAccelerationStructuresKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos) const18706 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::buildAccelerationStructuresKHR( 18707 VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 18708 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos, 18709 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) const 18710 { 18711 VULKAN_HPP_ASSERT( getDispatcher()->vkBuildAccelerationStructuresKHR && 18712 "Function <vkBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" ); 18713 # ifdef VULKAN_HPP_NO_EXCEPTIONS 18714 VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); 18715 # else 18716 if ( infos.size() != pBuildRangeInfos.size() ) 18717 { 18718 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); 18719 } 18720 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 18721 18722 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBuildAccelerationStructuresKHR( 18723 static_cast<VkDevice>( m_device ), 18724 static_cast<VkDeferredOperationKHR>( deferredOperation ), 18725 infos.size(), 18726 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ), 18727 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ) ); 18728 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 18729 VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR", 18730 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 18731 VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, 18732 VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); 18733 18734 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 18735 } 18736 18737 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info) const18738 Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 18739 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const 18740 { 18741 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyAccelerationStructureKHR && 18742 "Function <vkCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); 18743 18744 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18745 getDispatcher()->vkCopyAccelerationStructureKHR( static_cast<VkDevice>( m_device ), 18746 static_cast<VkDeferredOperationKHR>( deferredOperation ), 18747 reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ) ); 18748 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 18749 VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR", 18750 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 18751 VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, 18752 VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); 18753 18754 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 18755 } 18756 18757 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result copyAccelerationStructureToMemoryKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info) const18758 Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 18759 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const 18760 { 18761 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyAccelerationStructureToMemoryKHR && 18762 "Function <vkCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" ); 18763 18764 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18765 getDispatcher()->vkCopyAccelerationStructureToMemoryKHR( static_cast<VkDevice>( m_device ), 18766 static_cast<VkDeferredOperationKHR>( deferredOperation ), 18767 reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ) ); 18768 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 18769 VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR", 18770 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 18771 VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, 18772 VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); 18773 18774 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 18775 } 18776 18777 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result copyMemoryToAccelerationStructureKHR(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info) const18778 Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 18779 const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const 18780 { 18781 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToAccelerationStructureKHR && 18782 "Function <vkCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); 18783 18784 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18785 getDispatcher()->vkCopyMemoryToAccelerationStructureKHR( static_cast<VkDevice>( m_device ), 18786 static_cast<VkDeferredOperationKHR>( deferredOperation ), 18787 reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ) ); 18788 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 18789 VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR", 18790 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 18791 VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, 18792 VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); 18793 18794 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 18795 } 18796 18797 template <typename DataType> writeAccelerationStructuresPropertiesKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,VULKAN_HPP_NAMESPACE::QueryType queryType,size_t dataSize,size_t stride) const18798 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> Device::writeAccelerationStructuresPropertiesKHR( 18799 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 18800 VULKAN_HPP_NAMESPACE::QueryType queryType, 18801 size_t dataSize, 18802 size_t stride ) const 18803 { 18804 VULKAN_HPP_ASSERT( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR && 18805 "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" ); 18806 18807 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); 18808 std::vector<DataType> data( dataSize / sizeof( DataType ) ); 18809 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18810 getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast<VkDevice>( m_device ), 18811 accelerationStructures.size(), 18812 reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), 18813 static_cast<VkQueryType>( queryType ), 18814 data.size() * sizeof( DataType ), 18815 reinterpret_cast<void *>( data.data() ), 18816 stride ) ); 18817 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); 18818 18819 return data; 18820 } 18821 18822 template <typename DataType> writeAccelerationStructuresPropertyKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,VULKAN_HPP_NAMESPACE::QueryType queryType,size_t stride) const18823 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Device::writeAccelerationStructuresPropertyKHR( 18824 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 18825 VULKAN_HPP_NAMESPACE::QueryType queryType, 18826 size_t stride ) const 18827 { 18828 VULKAN_HPP_ASSERT( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR && 18829 "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" ); 18830 18831 DataType data; 18832 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 18833 getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast<VkDevice>( m_device ), 18834 accelerationStructures.size(), 18835 reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), 18836 static_cast<VkQueryType>( queryType ), 18837 sizeof( DataType ), 18838 reinterpret_cast<void *>( &data ), 18839 stride ) ); 18840 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); 18841 18842 return data; 18843 } 18844 18845 VULKAN_HPP_INLINE void copyAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info) const18846 CommandBuffer::copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT 18847 { 18848 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureKHR && 18849 "Function <vkCmdCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); 18850 18851 getDispatcher()->vkCmdCopyAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 18852 reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ); 18853 } 18854 copyAccelerationStructureToMemoryKHR(const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info) const18855 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( 18856 const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT 18857 { 18858 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR && 18859 "Function <vkCmdCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" ); 18860 18861 getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 18862 reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ); 18863 } 18864 copyMemoryToAccelerationStructureKHR(const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info) const18865 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( 18866 const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT 18867 { 18868 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR && 18869 "Function <vkCmdCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" ); 18870 18871 getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 18872 reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ); 18873 } 18874 18875 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress getAccelerationStructureAddressKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info) const18876 Device::getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT 18877 { 18878 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR && 18879 "Function <vkGetAccelerationStructureDeviceAddressKHR> requires <VK_KHR_acceleration_structure>" ); 18880 18881 VkDeviceAddress result = getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR( 18882 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) ); 18883 18884 return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); 18885 } 18886 writeAccelerationStructuresPropertiesKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,VULKAN_HPP_NAMESPACE::QueryType queryType,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t firstQuery) const18887 VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( 18888 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures, 18889 VULKAN_HPP_NAMESPACE::QueryType queryType, 18890 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 18891 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT 18892 { 18893 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR && 18894 "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" ); 18895 18896 getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 18897 accelerationStructures.size(), 18898 reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ), 18899 static_cast<VkQueryType>( queryType ), 18900 static_cast<VkQueryPool>( queryPool ), 18901 firstQuery ); 18902 } 18903 getAccelerationStructureCompatibilityKHR(const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo) const18904 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR Device::getAccelerationStructureCompatibilityKHR( 18905 const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT 18906 { 18907 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR && 18908 "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> requires <VK_KHR_acceleration_structure>" ); 18909 18910 VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility; 18911 getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR( static_cast<VkDevice>( m_device ), 18912 reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ), 18913 reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) ); 18914 18915 return compatibility; 18916 } 18917 18918 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo,VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts) const18919 Device::getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, 18920 const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo, 18921 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts ) const 18922 { 18923 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureBuildSizesKHR && 18924 "Function <vkGetAccelerationStructureBuildSizesKHR> requires <VK_KHR_acceleration_structure>" ); 18925 # ifdef VULKAN_HPP_NO_EXCEPTIONS 18926 VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount ); 18927 # else 18928 if ( maxPrimitiveCounts.size() != buildInfo.geometryCount ) 18929 { 18930 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" ); 18931 } 18932 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 18933 18934 VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR sizeInfo; 18935 getDispatcher()->vkGetAccelerationStructureBuildSizesKHR( static_cast<VkDevice>( m_device ), 18936 static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ), 18937 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ), 18938 maxPrimitiveCounts.data(), 18939 reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) ); 18940 18941 return sizeInfo; 18942 } 18943 18944 //=== VK_KHR_ray_tracing_pipeline === 18945 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) const18946 VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, 18947 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, 18948 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, 18949 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, 18950 uint32_t width, 18951 uint32_t height, 18952 uint32_t depth ) const VULKAN_HPP_NOEXCEPT 18953 { 18954 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysKHR && "Function <vkCmdTraceRaysKHR> requires <VK_KHR_ray_tracing_pipeline>" ); 18955 18956 getDispatcher()->vkCmdTraceRaysKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 18957 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ), 18958 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ), 18959 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ), 18960 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ), 18961 width, 18962 height, 18963 depth ); 18964 } 18965 18966 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 18967 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type 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) const18968 Device::createRayTracingPipelinesKHR( 18969 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 18970 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 18971 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos, 18972 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 18973 { 18974 std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); 18975 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesKHR( 18976 static_cast<VkDevice>( m_device ), 18977 deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0, 18978 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 18979 createInfos.size(), 18980 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ), 18981 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 18982 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); 18983 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) && 18984 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 18985 { 18986 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 18987 return VULKAN_HPP_UNEXPECTED( result ); 18988 # else 18989 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRayTracingPipelinesKHR" ); 18990 # endif 18991 } 18992 18993 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII; 18994 pipelinesRAII.reserve( pipelines.size() ); 18995 for ( auto & pipeline : pipelines ) 18996 { 18997 pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 18998 } 18999 return pipelinesRAII; 19000 } 19001 19002 VULKAN_HPP_NODISCARD 19003 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type 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) const19004 Device::createRayTracingPipelineKHR( 19005 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation, 19006 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 19007 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo, 19008 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 19009 { 19010 VULKAN_HPP_NAMESPACE::Pipeline pipeline; 19011 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesKHR( 19012 static_cast<VkDevice>( m_device ), 19013 deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0, 19014 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 19015 1, 19016 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ), 19017 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 19018 reinterpret_cast<VkPipeline *>( &pipeline ) ) ); 19019 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) && 19020 ( result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 19021 { 19022 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 19023 return VULKAN_HPP_UNEXPECTED( result ); 19024 # else 19025 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRayTracingPipelineKHR" ); 19026 # endif 19027 } 19028 19029 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 19030 } 19031 19032 template <typename DataType> 19033 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> getRayTracingShaderGroupHandlesKHR(uint32_t firstGroup,uint32_t groupCount,size_t dataSize) const19034 Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const 19035 { 19036 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR && 19037 "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" ); 19038 19039 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); 19040 std::vector<DataType> data( dataSize / sizeof( DataType ) ); 19041 VULKAN_HPP_NAMESPACE::Result result = 19042 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), 19043 static_cast<VkPipeline>( m_pipeline ), 19044 firstGroup, 19045 groupCount, 19046 data.size() * sizeof( DataType ), 19047 reinterpret_cast<void *>( data.data() ) ) ); 19048 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesKHR" ); 19049 19050 return data; 19051 } 19052 19053 template <typename DataType> getRayTracingShaderGroupHandleKHR(uint32_t firstGroup,uint32_t groupCount) const19054 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const 19055 { 19056 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR && 19057 "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" ); 19058 19059 DataType data; 19060 VULKAN_HPP_NAMESPACE::Result result = 19061 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), 19062 static_cast<VkPipeline>( m_pipeline ), 19063 firstGroup, 19064 groupCount, 19065 sizeof( DataType ), 19066 reinterpret_cast<void *>( &data ) ) ); 19067 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleKHR" ); 19068 19069 return data; 19070 } 19071 19072 template <typename DataType> 19073 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> getRayTracingCaptureReplayShaderGroupHandlesKHR(uint32_t firstGroup,uint32_t groupCount,size_t dataSize) const19074 Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const 19075 { 19076 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && 19077 "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); 19078 19079 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); 19080 std::vector<DataType> data( dataSize / sizeof( DataType ) ); 19081 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19082 getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), 19083 static_cast<VkPipeline>( m_pipeline ), 19084 firstGroup, 19085 groupCount, 19086 data.size() * sizeof( DataType ), 19087 reinterpret_cast<void *>( data.data() ) ) ); 19088 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); 19089 19090 return data; 19091 } 19092 19093 template <typename DataType> getRayTracingCaptureReplayShaderGroupHandleKHR(uint32_t firstGroup,uint32_t groupCount) const19094 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const 19095 { 19096 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && 19097 "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" ); 19098 19099 DataType data; 19100 VULKAN_HPP_NAMESPACE::Result result = 19101 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ), 19102 static_cast<VkPipeline>( m_pipeline ), 19103 firstGroup, 19104 groupCount, 19105 sizeof( DataType ), 19106 reinterpret_cast<void *>( &data ) ) ); 19107 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR" ); 19108 19109 return data; 19110 } 19111 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) const19112 VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable, 19113 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable, 19114 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable, 19115 const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable, 19116 VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT 19117 { 19118 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirectKHR && "Function <vkCmdTraceRaysIndirectKHR> requires <VK_KHR_ray_tracing_pipeline>" ); 19119 19120 getDispatcher()->vkCmdTraceRaysIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 19121 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ), 19122 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ), 19123 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ), 19124 reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ), 19125 static_cast<VkDeviceAddress>( indirectDeviceAddress ) ); 19126 } 19127 19128 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize getRayTracingShaderGroupStackSizeKHR(uint32_t group,VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader) const19129 Pipeline::getRayTracingShaderGroupStackSizeKHR( uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT 19130 { 19131 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR && 19132 "Function <vkGetRayTracingShaderGroupStackSizeKHR> requires <VK_KHR_ray_tracing_pipeline>" ); 19133 19134 VkDeviceSize result = getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR( 19135 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), group, static_cast<VkShaderGroupShaderKHR>( groupShader ) ); 19136 19137 return static_cast<VULKAN_HPP_NAMESPACE::DeviceSize>( result ); 19138 } 19139 setRayTracingPipelineStackSizeKHR(uint32_t pipelineStackSize) const19140 VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT 19141 { 19142 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR && 19143 "Function <vkCmdSetRayTracingPipelineStackSizeKHR> requires <VK_KHR_ray_tracing_pipeline>" ); 19144 19145 getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), pipelineStackSize ); 19146 } 19147 19148 //=== VK_KHR_sampler_ycbcr_conversion === 19149 19150 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 19151 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion>::Type createSamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const19152 Device::createSamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo, 19153 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 19154 VULKAN_HPP_RAII_CREATE_NOEXCEPT 19155 { 19156 VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; 19157 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSamplerYcbcrConversionKHR( 19158 static_cast<VkDevice>( m_device ), 19159 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ), 19160 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 19161 reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) ); 19162 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 19163 { 19164 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 19165 return VULKAN_HPP_UNEXPECTED( result ); 19166 # else 19167 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSamplerYcbcrConversionKHR" ); 19168 # endif 19169 } 19170 19171 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion( 19172 *this, *reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ), allocator ); 19173 } 19174 19175 VULKAN_HPP_INLINE void destroySamplerYcbcrConversionKHR(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const19176 Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, 19177 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT 19178 { 19179 VULKAN_HPP_ASSERT( getDispatcher()->vkDestroySamplerYcbcrConversionKHR && 19180 "Function <vkDestroySamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" ); 19181 19182 getDispatcher()->vkDestroySamplerYcbcrConversionKHR( 19183 static_cast<VkDevice>( m_device ), 19184 static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), 19185 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); 19186 } 19187 19188 //=== VK_KHR_bind_memory2 === 19189 19190 VULKAN_HPP_INLINE void bindBufferMemory2KHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos) const19191 Device::bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const 19192 { 19193 VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2KHR && "Function <vkBindBufferMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" ); 19194 19195 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindBufferMemory2KHR( 19196 static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) ); 19197 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); 19198 } 19199 19200 VULKAN_HPP_INLINE void bindImageMemory2KHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos) const19201 Device::bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const 19202 { 19203 VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2KHR && "Function <vkBindImageMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" ); 19204 19205 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindImageMemory2KHR( 19206 static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) ); 19207 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); 19208 } 19209 19210 //=== VK_EXT_image_drm_format_modifier === 19211 getDrmFormatModifierPropertiesEXT() const19212 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT Image::getDrmFormatModifierPropertiesEXT() const 19213 { 19214 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT && 19215 "Function <vkGetImageDrmFormatModifierPropertiesEXT> requires <VK_EXT_image_drm_format_modifier>" ); 19216 19217 VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties; 19218 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT( 19219 static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) ); 19220 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" ); 19221 19222 return properties; 19223 } 19224 19225 //=== VK_EXT_validation_cache === 19226 19227 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 19228 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT>::Type createValidationCacheEXT(VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const19229 Device::createValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo, 19230 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 19231 VULKAN_HPP_RAII_CREATE_NOEXCEPT 19232 { 19233 VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache; 19234 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateValidationCacheEXT( 19235 static_cast<VkDevice>( m_device ), 19236 reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ), 19237 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 19238 reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) ); 19239 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 19240 { 19241 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 19242 return VULKAN_HPP_UNEXPECTED( result ); 19243 # else 19244 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createValidationCacheEXT" ); 19245 # endif 19246 } 19247 19248 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT( 19249 *this, *reinterpret_cast<VkValidationCacheEXT *>( &validationCache ), allocator ); 19250 } 19251 merge(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches) const19252 VULKAN_HPP_INLINE void ValidationCacheEXT::merge( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const 19253 { 19254 VULKAN_HPP_ASSERT( getDispatcher()->vkMergeValidationCachesEXT && "Function <vkMergeValidationCachesEXT> requires <VK_EXT_validation_cache>" ); 19255 19256 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19257 getDispatcher()->vkMergeValidationCachesEXT( static_cast<VkDevice>( m_device ), 19258 static_cast<VkValidationCacheEXT>( m_validationCache ), 19259 srcCaches.size(), 19260 reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) ); 19261 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::merge" ); 19262 } 19263 getData() const19264 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ValidationCacheEXT::getData() const 19265 { 19266 VULKAN_HPP_ASSERT( getDispatcher()->vkGetValidationCacheDataEXT && "Function <vkGetValidationCacheDataEXT> requires <VK_EXT_validation_cache>" ); 19267 19268 std::vector<uint8_t> data; 19269 size_t dataSize; 19270 VULKAN_HPP_NAMESPACE::Result result; 19271 do 19272 { 19273 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetValidationCacheDataEXT( 19274 static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( m_validationCache ), &dataSize, nullptr ) ); 19275 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) 19276 { 19277 data.resize( dataSize ); 19278 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetValidationCacheDataEXT( 19279 static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( m_validationCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) ); 19280 } 19281 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 19282 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::getData" ); 19283 VULKAN_HPP_ASSERT( dataSize <= data.size() ); 19284 if ( dataSize < data.size() ) 19285 { 19286 data.resize( dataSize ); 19287 } 19288 return data; 19289 } 19290 19291 //=== VK_NV_shading_rate_image === 19292 bindShadingRateImageNV(VULKAN_HPP_NAMESPACE::ImageView imageView,VULKAN_HPP_NAMESPACE::ImageLayout imageLayout) const19293 VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, 19294 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT 19295 { 19296 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadingRateImageNV && "Function <vkCmdBindShadingRateImageNV> requires <VK_NV_shading_rate_image>" ); 19297 19298 getDispatcher()->vkCmdBindShadingRateImageNV( 19299 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) ); 19300 } 19301 setViewportShadingRatePaletteNV(uint32_t firstViewport,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes) const19302 VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( 19303 uint32_t firstViewport, 19304 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT 19305 { 19306 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportShadingRatePaletteNV && 19307 "Function <vkCmdSetViewportShadingRatePaletteNV> requires <VK_NV_shading_rate_image>" ); 19308 19309 getDispatcher()->vkCmdSetViewportShadingRatePaletteNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 19310 firstViewport, 19311 shadingRatePalettes.size(), 19312 reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) ); 19313 } 19314 setCoarseSampleOrderNV(VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders) const19315 VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( 19316 VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType, 19317 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders ) const VULKAN_HPP_NOEXCEPT 19318 { 19319 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoarseSampleOrderNV && "Function <vkCmdSetCoarseSampleOrderNV> requires <VK_NV_shading_rate_image>" ); 19320 19321 getDispatcher()->vkCmdSetCoarseSampleOrderNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 19322 static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), 19323 customSampleOrders.size(), 19324 reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) ); 19325 } 19326 19327 //=== VK_NV_ray_tracing === 19328 19329 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 19330 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV>::Type createAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const19331 Device::createAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo, 19332 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 19333 VULKAN_HPP_RAII_CREATE_NOEXCEPT 19334 { 19335 VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure; 19336 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateAccelerationStructureNV( 19337 static_cast<VkDevice>( m_device ), 19338 reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ), 19339 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 19340 reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) ); 19341 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 19342 { 19343 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 19344 return VULKAN_HPP_UNEXPECTED( result ); 19345 # else 19346 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createAccelerationStructureNV" ); 19347 # endif 19348 } 19349 19350 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV( 19351 *this, *reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ), allocator ); 19352 } 19353 getAccelerationStructureMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info) const19354 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( 19355 const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT 19356 { 19357 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && 19358 "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" ); 19359 19360 VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR memoryRequirements; 19361 getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast<VkDevice>( m_device ), 19362 reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ), 19363 reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) ); 19364 19365 return memoryRequirements; 19366 } 19367 19368 template <typename X, typename Y, typename... Z> getAccelerationStructureMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info) const19369 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> Device::getAccelerationStructureMemoryRequirementsNV( 19370 const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT 19371 { 19372 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && 19373 "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" ); 19374 19375 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 19376 VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>(); 19377 getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast<VkDevice>( m_device ), 19378 reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ), 19379 reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) ); 19380 19381 return structureChain; 19382 } 19383 bindAccelerationStructureMemoryNV(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos) const19384 VULKAN_HPP_INLINE void Device::bindAccelerationStructureMemoryNV( 19385 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const 19386 { 19387 VULKAN_HPP_ASSERT( getDispatcher()->vkBindAccelerationStructureMemoryNV && 19388 "Function <vkBindAccelerationStructureMemoryNV> requires <VK_NV_ray_tracing>" ); 19389 19390 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindAccelerationStructureMemoryNV( 19391 static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) ); 19392 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); 19393 } 19394 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) const19395 VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info, 19396 VULKAN_HPP_NAMESPACE::Buffer instanceData, 19397 VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset, 19398 VULKAN_HPP_NAMESPACE::Bool32 update, 19399 VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, 19400 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, 19401 VULKAN_HPP_NAMESPACE::Buffer scratch, 19402 VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT 19403 { 19404 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructureNV && "Function <vkCmdBuildAccelerationStructureNV> requires <VK_NV_ray_tracing>" ); 19405 19406 getDispatcher()->vkCmdBuildAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 19407 reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ), 19408 static_cast<VkBuffer>( instanceData ), 19409 static_cast<VkDeviceSize>( instanceOffset ), 19410 static_cast<VkBool32>( update ), 19411 static_cast<VkAccelerationStructureNV>( dst ), 19412 static_cast<VkAccelerationStructureNV>( src ), 19413 static_cast<VkBuffer>( scratch ), 19414 static_cast<VkDeviceSize>( scratchOffset ) ); 19415 } 19416 copyAccelerationStructureNV(VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode) const19417 VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, 19418 VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, 19419 VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT 19420 { 19421 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureNV && "Function <vkCmdCopyAccelerationStructureNV> requires <VK_NV_ray_tracing>" ); 19422 19423 getDispatcher()->vkCmdCopyAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 19424 static_cast<VkAccelerationStructureNV>( dst ), 19425 static_cast<VkAccelerationStructureNV>( src ), 19426 static_cast<VkCopyAccelerationStructureModeKHR>( mode ) ); 19427 } 19428 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) const19429 VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, 19430 VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset, 19431 VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, 19432 VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset, 19433 VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride, 19434 VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, 19435 VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset, 19436 VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride, 19437 VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, 19438 VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset, 19439 VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride, 19440 uint32_t width, 19441 uint32_t height, 19442 uint32_t depth ) const VULKAN_HPP_NOEXCEPT 19443 { 19444 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysNV && "Function <vkCmdTraceRaysNV> requires <VK_NV_ray_tracing>" ); 19445 19446 getDispatcher()->vkCmdTraceRaysNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 19447 static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), 19448 static_cast<VkDeviceSize>( raygenShaderBindingOffset ), 19449 static_cast<VkBuffer>( missShaderBindingTableBuffer ), 19450 static_cast<VkDeviceSize>( missShaderBindingOffset ), 19451 static_cast<VkDeviceSize>( missShaderBindingStride ), 19452 static_cast<VkBuffer>( hitShaderBindingTableBuffer ), 19453 static_cast<VkDeviceSize>( hitShaderBindingOffset ), 19454 static_cast<VkDeviceSize>( hitShaderBindingStride ), 19455 static_cast<VkBuffer>( callableShaderBindingTableBuffer ), 19456 static_cast<VkDeviceSize>( callableShaderBindingOffset ), 19457 static_cast<VkDeviceSize>( callableShaderBindingStride ), 19458 width, 19459 height, 19460 depth ); 19461 } 19462 19463 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 19464 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type 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) const19465 Device::createRayTracingPipelinesNV( 19466 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 19467 VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos, 19468 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 19469 { 19470 std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() ); 19471 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesNV( 19472 static_cast<VkDevice>( m_device ), 19473 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 19474 createInfos.size(), 19475 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ), 19476 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 19477 reinterpret_cast<VkPipeline *>( pipelines.data() ) ) ); 19478 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 19479 { 19480 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 19481 return VULKAN_HPP_UNEXPECTED( result ); 19482 # else 19483 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRayTracingPipelinesNV" ); 19484 # endif 19485 } 19486 19487 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII; 19488 pipelinesRAII.reserve( pipelines.size() ); 19489 for ( auto & pipeline : pipelines ) 19490 { 19491 pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 19492 } 19493 return pipelinesRAII; 19494 } 19495 19496 VULKAN_HPP_NODISCARD 19497 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type 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) const19498 Device::createRayTracingPipelineNV( 19499 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache, 19500 VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo, 19501 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 19502 { 19503 VULKAN_HPP_NAMESPACE::Pipeline pipeline; 19504 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesNV( 19505 static_cast<VkDevice>( m_device ), 19506 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0, 19507 1, 19508 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ), 19509 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 19510 reinterpret_cast<VkPipeline *>( &pipeline ) ) ); 19511 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) ) 19512 { 19513 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 19514 return VULKAN_HPP_UNEXPECTED( result ); 19515 # else 19516 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRayTracingPipelineNV" ); 19517 # endif 19518 } 19519 19520 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result ); 19521 } 19522 19523 template <typename DataType> 19524 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> getRayTracingShaderGroupHandlesNV(uint32_t firstGroup,uint32_t groupCount,size_t dataSize) const19525 Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const 19526 { 19527 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV && 19528 "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" ); 19529 19530 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); 19531 std::vector<DataType> data( dataSize / sizeof( DataType ) ); 19532 VULKAN_HPP_NAMESPACE::Result result = 19533 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ), 19534 static_cast<VkPipeline>( m_pipeline ), 19535 firstGroup, 19536 groupCount, 19537 data.size() * sizeof( DataType ), 19538 reinterpret_cast<void *>( data.data() ) ) ); 19539 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesNV" ); 19540 19541 return data; 19542 } 19543 19544 template <typename DataType> getRayTracingShaderGroupHandleNV(uint32_t firstGroup,uint32_t groupCount) const19545 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const 19546 { 19547 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV && 19548 "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" ); 19549 19550 DataType data; 19551 VULKAN_HPP_NAMESPACE::Result result = 19552 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ), 19553 static_cast<VkPipeline>( m_pipeline ), 19554 firstGroup, 19555 groupCount, 19556 sizeof( DataType ), 19557 reinterpret_cast<void *>( &data ) ) ); 19558 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleNV" ); 19559 19560 return data; 19561 } 19562 19563 template <typename DataType> getHandle(size_t dataSize) const19564 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> AccelerationStructureNV::getHandle( size_t dataSize ) const 19565 { 19566 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" ); 19567 19568 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); 19569 std::vector<DataType> data( dataSize / sizeof( DataType ) ); 19570 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19571 getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast<VkDevice>( m_device ), 19572 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ), 19573 data.size() * sizeof( DataType ), 19574 reinterpret_cast<void *>( data.data() ) ) ); 19575 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); 19576 19577 return data; 19578 } 19579 19580 template <typename DataType> getHandle() const19581 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType AccelerationStructureNV::getHandle() const 19582 { 19583 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" ); 19584 19585 DataType data; 19586 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19587 getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast<VkDevice>( m_device ), 19588 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ), 19589 sizeof( DataType ), 19590 reinterpret_cast<void *>( &data ) ) ); 19591 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); 19592 19593 return data; 19594 } 19595 writeAccelerationStructuresPropertiesNV(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,VULKAN_HPP_NAMESPACE::QueryType queryType,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t firstQuery) const19596 VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( 19597 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures, 19598 VULKAN_HPP_NAMESPACE::QueryType queryType, 19599 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 19600 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT 19601 { 19602 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV && 19603 "Function <vkCmdWriteAccelerationStructuresPropertiesNV> requires <VK_NV_ray_tracing>" ); 19604 19605 getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 19606 accelerationStructures.size(), 19607 reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ), 19608 static_cast<VkQueryType>( queryType ), 19609 static_cast<VkQueryPool>( queryPool ), 19610 firstQuery ); 19611 } 19612 compileDeferredNV(uint32_t shader) const19613 VULKAN_HPP_INLINE void Pipeline::compileDeferredNV( uint32_t shader ) const 19614 { 19615 VULKAN_HPP_ASSERT( getDispatcher()->vkCompileDeferredNV && "Function <vkCompileDeferredNV> requires <VK_NV_ray_tracing>" ); 19616 19617 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19618 getDispatcher()->vkCompileDeferredNV( static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), shader ) ); 19619 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::compileDeferredNV" ); 19620 } 19621 19622 //=== VK_KHR_maintenance3 === 19623 19624 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo) const19625 Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 19626 { 19627 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && 19628 "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" ); 19629 19630 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support; 19631 getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast<VkDevice>( m_device ), 19632 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 19633 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); 19634 19635 return support; 19636 } 19637 19638 template <typename X, typename Y, typename... Z> 19639 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR(const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo) const19640 Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 19641 { 19642 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && 19643 "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" ); 19644 19645 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 19646 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>(); 19647 getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast<VkDevice>( m_device ), 19648 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ), 19649 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) ); 19650 19651 return structureChain; 19652 } 19653 19654 //=== VK_KHR_draw_indirect_count === 19655 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) const19656 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 19657 VULKAN_HPP_NAMESPACE::DeviceSize offset, 19658 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 19659 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 19660 uint32_t maxDrawCount, 19661 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 19662 { 19663 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountKHR && 19664 "Function <vkCmdDrawIndirectCountKHR> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" ); 19665 19666 getDispatcher()->vkCmdDrawIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 19667 static_cast<VkBuffer>( buffer ), 19668 static_cast<VkDeviceSize>( offset ), 19669 static_cast<VkBuffer>( countBuffer ), 19670 static_cast<VkDeviceSize>( countBufferOffset ), 19671 maxDrawCount, 19672 stride ); 19673 } 19674 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) const19675 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 19676 VULKAN_HPP_NAMESPACE::DeviceSize offset, 19677 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 19678 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 19679 uint32_t maxDrawCount, 19680 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 19681 { 19682 VULKAN_HPP_ASSERT( 19683 getDispatcher()->vkCmdDrawIndexedIndirectCountKHR && 19684 "Function <vkCmdDrawIndexedIndirectCountKHR> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" ); 19685 19686 getDispatcher()->vkCmdDrawIndexedIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 19687 static_cast<VkBuffer>( buffer ), 19688 static_cast<VkDeviceSize>( offset ), 19689 static_cast<VkBuffer>( countBuffer ), 19690 static_cast<VkDeviceSize>( countBufferOffset ), 19691 maxDrawCount, 19692 stride ); 19693 } 19694 19695 //=== VK_EXT_external_memory_host === 19696 19697 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT getMemoryHostPointerPropertiesEXT(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,const void * pHostPointer) const19698 Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const 19699 { 19700 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryHostPointerPropertiesEXT && 19701 "Function <vkGetMemoryHostPointerPropertiesEXT> requires <VK_EXT_external_memory_host>" ); 19702 19703 VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties; 19704 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19705 getDispatcher()->vkGetMemoryHostPointerPropertiesEXT( static_cast<VkDevice>( m_device ), 19706 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), 19707 pHostPointer, 19708 reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) ) ); 19709 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); 19710 19711 return memoryHostPointerProperties; 19712 } 19713 19714 //=== VK_AMD_buffer_marker === 19715 writeBufferMarkerAMD(VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,uint32_t marker) const19716 VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage, 19717 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 19718 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 19719 uint32_t marker ) const VULKAN_HPP_NOEXCEPT 19720 { 19721 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarkerAMD && "Function <vkCmdWriteBufferMarkerAMD> requires <VK_AMD_buffer_marker>" ); 19722 19723 getDispatcher()->vkCmdWriteBufferMarkerAMD( static_cast<VkCommandBuffer>( m_commandBuffer ), 19724 static_cast<VkPipelineStageFlagBits>( pipelineStage ), 19725 static_cast<VkBuffer>( dstBuffer ), 19726 static_cast<VkDeviceSize>( dstOffset ), 19727 marker ); 19728 } 19729 19730 //=== VK_EXT_calibrated_timestamps === 19731 getCalibrateableTimeDomainsEXT() const19732 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> PhysicalDevice::getCalibrateableTimeDomainsEXT() const 19733 { 19734 VULKAN_HPP_ASSERT( 19735 getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && 19736 "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); 19737 19738 std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> timeDomains; 19739 uint32_t timeDomainCount; 19740 VULKAN_HPP_NAMESPACE::Result result; 19741 do 19742 { 19743 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19744 getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr ) ); 19745 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount ) 19746 { 19747 timeDomains.resize( timeDomainCount ); 19748 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( 19749 static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) ); 19750 } 19751 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 19752 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); 19753 VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); 19754 if ( timeDomainCount < timeDomains.size() ) 19755 { 19756 timeDomains.resize( timeDomainCount ); 19757 } 19758 return timeDomains; 19759 } 19760 getCalibratedTimestampsEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos) const19761 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t> Device::getCalibratedTimestampsEXT( 19762 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const 19763 { 19764 VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && 19765 "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); 19766 19767 std::pair<std::vector<uint64_t>, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); 19768 std::vector<uint64_t> & timestamps = data_.first; 19769 uint64_t & maxDeviation = data_.second; 19770 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19771 getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast<VkDevice>( m_device ), 19772 timestampInfos.size(), 19773 reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), 19774 timestamps.data(), 19775 &maxDeviation ) ); 19776 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); 19777 19778 return data_; 19779 } 19780 19781 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t> getCalibratedTimestampEXT(const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo) const19782 Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const 19783 { 19784 VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && 19785 "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); 19786 19787 std::pair<uint64_t, uint64_t> data_; 19788 uint64_t & timestamp = data_.first; 19789 uint64_t & maxDeviation = data_.second; 19790 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsEXT( 19791 static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( ×tampInfo ), ×tamp, &maxDeviation ) ); 19792 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); 19793 19794 return data_; 19795 } 19796 19797 //=== VK_NV_mesh_shader === 19798 drawMeshTasksNV(uint32_t taskCount,uint32_t firstTask) const19799 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT 19800 { 19801 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksNV && "Function <vkCmdDrawMeshTasksNV> requires <VK_NV_mesh_shader>" ); 19802 19803 getDispatcher()->vkCmdDrawMeshTasksNV( static_cast<VkCommandBuffer>( m_commandBuffer ), taskCount, firstTask ); 19804 } 19805 drawMeshTasksIndirectNV(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,uint32_t drawCount,uint32_t stride) const19806 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, 19807 VULKAN_HPP_NAMESPACE::DeviceSize offset, 19808 uint32_t drawCount, 19809 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 19810 { 19811 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectNV && "Function <vkCmdDrawMeshTasksIndirectNV> requires <VK_NV_mesh_shader>" ); 19812 19813 getDispatcher()->vkCmdDrawMeshTasksIndirectNV( 19814 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); 19815 } 19816 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) const19817 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, 19818 VULKAN_HPP_NAMESPACE::DeviceSize offset, 19819 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 19820 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 19821 uint32_t maxDrawCount, 19822 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 19823 { 19824 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV && "Function <vkCmdDrawMeshTasksIndirectCountNV> requires <VK_NV_mesh_shader>" ); 19825 19826 getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 19827 static_cast<VkBuffer>( buffer ), 19828 static_cast<VkDeviceSize>( offset ), 19829 static_cast<VkBuffer>( countBuffer ), 19830 static_cast<VkDeviceSize>( countBufferOffset ), 19831 maxDrawCount, 19832 stride ); 19833 } 19834 19835 //=== VK_NV_scissor_exclusive === 19836 setExclusiveScissorEnableNV(uint32_t firstExclusiveScissor,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables) const19837 VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( 19838 uint32_t firstExclusiveScissor, 19839 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT 19840 { 19841 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorEnableNV && 19842 "Function <vkCmdSetExclusiveScissorEnableNV> requires <VK_NV_scissor_exclusive>" ); 19843 19844 getDispatcher()->vkCmdSetExclusiveScissorEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 19845 firstExclusiveScissor, 19846 exclusiveScissorEnables.size(), 19847 reinterpret_cast<const VkBool32 *>( exclusiveScissorEnables.data() ) ); 19848 } 19849 setExclusiveScissorNV(uint32_t firstExclusiveScissor,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors) const19850 VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( 19851 uint32_t firstExclusiveScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT 19852 { 19853 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorNV && "Function <vkCmdSetExclusiveScissorNV> requires <VK_NV_scissor_exclusive>" ); 19854 19855 getDispatcher()->vkCmdSetExclusiveScissorNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 19856 firstExclusiveScissor, 19857 exclusiveScissors.size(), 19858 reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) ); 19859 } 19860 19861 //=== VK_NV_device_diagnostic_checkpoints === 19862 19863 template <typename CheckpointMarkerType> setCheckpointNV(CheckpointMarkerType const & checkpointMarker) const19864 VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT 19865 { 19866 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCheckpointNV && "Function <vkCmdSetCheckpointNV> requires <VK_NV_device_diagnostic_checkpoints>" ); 19867 19868 getDispatcher()->vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const void *>( &checkpointMarker ) ); 19869 } 19870 getCheckpointDataNV() const19871 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> Queue::getCheckpointDataNV() const 19872 { 19873 VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointDataNV && 19874 "Function <vkGetQueueCheckpointDataNV> requires <VK_NV_device_diagnostic_checkpoints>" ); 19875 19876 std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> checkpointData; 19877 uint32_t checkpointDataCount; 19878 getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr ); 19879 checkpointData.resize( checkpointDataCount ); 19880 getDispatcher()->vkGetQueueCheckpointDataNV( 19881 static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) ); 19882 19883 VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); 19884 if ( checkpointDataCount < checkpointData.size() ) 19885 { 19886 checkpointData.resize( checkpointDataCount ); 19887 } 19888 return checkpointData; 19889 } 19890 19891 //=== VK_KHR_timeline_semaphore === 19892 getCounterValueKHR() const19893 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValueKHR() const 19894 { 19895 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreCounterValueKHR && 19896 "Function <vkGetSemaphoreCounterValueKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); 19897 19898 uint64_t value; 19899 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19900 getDispatcher()->vkGetSemaphoreCounterValueKHR( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) ); 19901 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" ); 19902 19903 return value; 19904 } 19905 waitSemaphoresKHR(const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,uint64_t timeout) const19906 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, 19907 uint64_t timeout ) const 19908 { 19909 VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphoresKHR && "Function <vkWaitSemaphoresKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); 19910 19911 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19912 getDispatcher()->vkWaitSemaphoresKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) ); 19913 VULKAN_HPP_NAMESPACE::detail::resultCheck( 19914 result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } ); 19915 19916 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 19917 } 19918 signalSemaphoreKHR(const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo) const19919 VULKAN_HPP_INLINE void Device::signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const 19920 { 19921 VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphoreKHR && "Function <vkSignalSemaphoreKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" ); 19922 19923 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19924 getDispatcher()->vkSignalSemaphoreKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) ); 19925 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); 19926 } 19927 19928 //=== VK_INTEL_performance_query === 19929 initializePerformanceApiINTEL(const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo) const19930 VULKAN_HPP_INLINE void Device::initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo ) const 19931 { 19932 VULKAN_HPP_ASSERT( getDispatcher()->vkInitializePerformanceApiINTEL && 19933 "Function <vkInitializePerformanceApiINTEL> requires <VK_INTEL_performance_query>" ); 19934 19935 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInitializePerformanceApiINTEL( 19936 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) ); 19937 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); 19938 } 19939 uninitializePerformanceApiINTEL() const19940 VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT 19941 { 19942 VULKAN_HPP_ASSERT( getDispatcher()->vkUninitializePerformanceApiINTEL && 19943 "Function <vkUninitializePerformanceApiINTEL> requires <VK_INTEL_performance_query>" ); 19944 19945 getDispatcher()->vkUninitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ) ); 19946 } 19947 setPerformanceMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo) const19948 VULKAN_HPP_INLINE void CommandBuffer::setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo ) const 19949 { 19950 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceMarkerINTEL && "Function <vkCmdSetPerformanceMarkerINTEL> requires <VK_INTEL_performance_query>" ); 19951 19952 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceMarkerINTEL( 19953 static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) ); 19954 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); 19955 } 19956 setPerformanceStreamMarkerINTEL(const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo) const19957 VULKAN_HPP_INLINE void CommandBuffer::setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo ) const 19958 { 19959 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL && 19960 "Function <vkCmdSetPerformanceStreamMarkerINTEL> requires <VK_INTEL_performance_query>" ); 19961 19962 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL( 19963 static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) ); 19964 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); 19965 } 19966 setPerformanceOverrideINTEL(const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo) const19967 VULKAN_HPP_INLINE void CommandBuffer::setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo ) const 19968 { 19969 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceOverrideINTEL && 19970 "Function <vkCmdSetPerformanceOverrideINTEL> requires <VK_INTEL_performance_query>" ); 19971 19972 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceOverrideINTEL( 19973 static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) ); 19974 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); 19975 } 19976 19977 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 19978 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL>::Type acquirePerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo) const19979 Device::acquirePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const 19980 VULKAN_HPP_RAII_CREATE_NOEXCEPT 19981 { 19982 VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration; 19983 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 19984 getDispatcher()->vkAcquirePerformanceConfigurationINTEL( static_cast<VkDevice>( m_device ), 19985 reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ), 19986 reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) ); 19987 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 19988 { 19989 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 19990 return VULKAN_HPP_UNEXPECTED( result ); 19991 # else 19992 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::acquirePerformanceConfigurationINTEL" ); 19993 # endif 19994 } 19995 19996 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL( 19997 *this, *reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ); 19998 } 19999 setPerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration) const20000 VULKAN_HPP_INLINE void Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const 20001 { 20002 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL && 20003 "Function <vkQueueSetPerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" ); 20004 20005 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL( 20006 static_cast<VkQueue>( m_queue ), static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) ); 20007 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); 20008 } 20009 20010 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PerformanceValueINTEL getPerformanceParameterINTEL(VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter) const20011 Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const 20012 { 20013 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPerformanceParameterINTEL && "Function <vkGetPerformanceParameterINTEL> requires <VK_INTEL_performance_query>" ); 20014 20015 VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value; 20016 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPerformanceParameterINTEL( 20017 static_cast<VkDevice>( m_device ), static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( &value ) ) ); 20018 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); 20019 20020 return value; 20021 } 20022 20023 //=== VK_AMD_display_native_hdr === 20024 setLocalDimmingAMD(VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable) const20025 VULKAN_HPP_INLINE void SwapchainKHR::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT 20026 { 20027 VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD && "Function <vkSetLocalDimmingAMD> requires <VK_AMD_display_native_hdr>" ); 20028 20029 getDispatcher()->vkSetLocalDimmingAMD( 20030 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkBool32>( localDimmingEnable ) ); 20031 } 20032 20033 # if defined( VK_USE_PLATFORM_FUCHSIA ) 20034 //=== VK_FUCHSIA_imagepipe_surface === 20035 20036 VULKAN_HPP_NODISCARD 20037 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createImagePipeSurfaceFUCHSIA(VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const20038 Instance::createImagePipeSurfaceFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, 20039 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 20040 VULKAN_HPP_RAII_CREATE_NOEXCEPT 20041 { 20042 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 20043 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA( 20044 static_cast<VkInstance>( m_instance ), 20045 reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ), 20046 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 20047 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 20048 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 20049 { 20050 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 20051 return VULKAN_HPP_UNEXPECTED( result ); 20052 # else 20053 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createImagePipeSurfaceFUCHSIA" ); 20054 # endif 20055 } 20056 20057 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 20058 } 20059 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 20060 20061 # if defined( VK_USE_PLATFORM_METAL_EXT ) 20062 //=== VK_EXT_metal_surface === 20063 20064 VULKAN_HPP_NODISCARD 20065 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createMetalSurfaceEXT(VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const20066 Instance::createMetalSurfaceEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo, 20067 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 20068 VULKAN_HPP_RAII_CREATE_NOEXCEPT 20069 { 20070 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 20071 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateMetalSurfaceEXT( 20072 static_cast<VkInstance>( m_instance ), 20073 reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ), 20074 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 20075 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 20076 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 20077 { 20078 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 20079 return VULKAN_HPP_UNEXPECTED( result ); 20080 # else 20081 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createMetalSurfaceEXT" ); 20082 # endif 20083 } 20084 20085 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 20086 } 20087 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 20088 20089 //=== VK_KHR_fragment_shading_rate === 20090 20091 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> getFragmentShadingRatesKHR() const20092 PhysicalDevice::getFragmentShadingRatesKHR() const 20093 { 20094 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR && 20095 "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> requires <VK_KHR_fragment_shading_rate>" ); 20096 20097 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> fragmentShadingRates; 20098 uint32_t fragmentShadingRateCount; 20099 VULKAN_HPP_NAMESPACE::Result result; 20100 do 20101 { 20102 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( 20103 static_cast<VkPhysicalDevice>( m_physicalDevice ), &fragmentShadingRateCount, nullptr ) ); 20104 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && fragmentShadingRateCount ) 20105 { 20106 fragmentShadingRates.resize( fragmentShadingRateCount ); 20107 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( 20108 static_cast<VkPhysicalDevice>( m_physicalDevice ), 20109 &fragmentShadingRateCount, 20110 reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) ); 20111 } 20112 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 20113 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); 20114 VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); 20115 if ( fragmentShadingRateCount < fragmentShadingRates.size() ) 20116 { 20117 fragmentShadingRates.resize( fragmentShadingRateCount ); 20118 } 20119 return fragmentShadingRates; 20120 } 20121 20122 VULKAN_HPP_INLINE void setFragmentShadingRateKHR(const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize,const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2]) const20123 CommandBuffer::setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize, 20124 const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT 20125 { 20126 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFragmentShadingRateKHR && 20127 "Function <vkCmdSetFragmentShadingRateKHR> requires <VK_KHR_fragment_shading_rate>" ); 20128 20129 getDispatcher()->vkCmdSetFragmentShadingRateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 20130 reinterpret_cast<const VkExtent2D *>( &fragmentSize ), 20131 reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); 20132 } 20133 20134 //=== VK_KHR_dynamic_rendering_local_read === 20135 20136 VULKAN_HPP_INLINE void setRenderingAttachmentLocationsKHR(const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo) const20137 CommandBuffer::setRenderingAttachmentLocationsKHR( const VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT 20138 { 20139 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingAttachmentLocationsKHR && 20140 "Function <vkCmdSetRenderingAttachmentLocationsKHR> requires <VK_KHR_dynamic_rendering_local_read> or <VK_VERSION_1_4>" ); 20141 20142 getDispatcher()->vkCmdSetRenderingAttachmentLocationsKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 20143 reinterpret_cast<const VkRenderingAttachmentLocationInfo *>( &locationInfo ) ); 20144 } 20145 setRenderingInputAttachmentIndicesKHR(const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo) const20146 VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( 20147 const VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT 20148 { 20149 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingInputAttachmentIndicesKHR && 20150 "Function <vkCmdSetRenderingInputAttachmentIndicesKHR> requires <VK_KHR_dynamic_rendering_local_read> or <VK_VERSION_1_4>" ); 20151 20152 getDispatcher()->vkCmdSetRenderingInputAttachmentIndicesKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 20153 reinterpret_cast<const VkRenderingInputAttachmentIndexInfo *>( &inputAttachmentIndexInfo ) ); 20154 } 20155 20156 //=== VK_EXT_buffer_device_address === 20157 20158 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressEXT(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const20159 Device::getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 20160 { 20161 VULKAN_HPP_ASSERT( 20162 getDispatcher()->vkGetBufferDeviceAddressEXT && 20163 "Function <vkGetBufferDeviceAddressEXT> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); 20164 20165 VkDeviceAddress result = 20166 getDispatcher()->vkGetBufferDeviceAddressEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); 20167 20168 return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); 20169 } 20170 20171 //=== VK_EXT_tooling_info === 20172 getToolPropertiesEXT() const20173 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> PhysicalDevice::getToolPropertiesEXT() const 20174 { 20175 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT && 20176 "Function <vkGetPhysicalDeviceToolPropertiesEXT> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" ); 20177 20178 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties; 20179 uint32_t toolCount; 20180 VULKAN_HPP_NAMESPACE::Result result; 20181 do 20182 { 20183 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20184 getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, nullptr ) ); 20185 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount ) 20186 { 20187 toolProperties.resize( toolCount ); 20188 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( 20189 static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) ); 20190 } 20191 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 20192 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); 20193 VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); 20194 if ( toolCount < toolProperties.size() ) 20195 { 20196 toolProperties.resize( toolCount ); 20197 } 20198 return toolProperties; 20199 } 20200 20201 //=== VK_KHR_present_wait === 20202 waitForPresent(uint64_t presentId,uint64_t timeout) const20203 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result SwapchainKHR::waitForPresent( uint64_t presentId, uint64_t timeout ) const 20204 { 20205 VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForPresentKHR && "Function <vkWaitForPresentKHR> requires <VK_KHR_present_wait>" ); 20206 20207 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20208 getDispatcher()->vkWaitForPresentKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), presentId, timeout ) ); 20209 VULKAN_HPP_NAMESPACE::detail::resultCheck( 20210 result, 20211 VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::waitForPresent", 20212 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); 20213 20214 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 20215 } 20216 20217 //=== VK_NV_cooperative_matrix === 20218 20219 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> getCooperativeMatrixPropertiesNV() const20220 PhysicalDevice::getCooperativeMatrixPropertiesNV() const 20221 { 20222 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && 20223 "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> requires <VK_NV_cooperative_matrix>" ); 20224 20225 std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> properties; 20226 uint32_t propertyCount; 20227 VULKAN_HPP_NAMESPACE::Result result; 20228 do 20229 { 20230 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20231 getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 20232 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 20233 { 20234 properties.resize( propertyCount ); 20235 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( 20236 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) ); 20237 } 20238 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 20239 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); 20240 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 20241 if ( propertyCount < properties.size() ) 20242 { 20243 properties.resize( propertyCount ); 20244 } 20245 return properties; 20246 } 20247 20248 //=== VK_NV_coverage_reduction_mode === 20249 20250 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> getSupportedFramebufferMixedSamplesCombinationsNV() const20251 PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV() const 20252 { 20253 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && 20254 "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> requires <VK_NV_coverage_reduction_mode>" ); 20255 20256 std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> combinations; 20257 uint32_t combinationCount; 20258 VULKAN_HPP_NAMESPACE::Result result; 20259 do 20260 { 20261 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 20262 static_cast<VkPhysicalDevice>( m_physicalDevice ), &combinationCount, nullptr ) ); 20263 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && combinationCount ) 20264 { 20265 combinations.resize( combinationCount ); 20266 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 20267 static_cast<VkPhysicalDevice>( m_physicalDevice ), 20268 &combinationCount, 20269 reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) ); 20270 } 20271 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 20272 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); 20273 VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); 20274 if ( combinationCount < combinations.size() ) 20275 { 20276 combinations.resize( combinationCount ); 20277 } 20278 return combinations; 20279 } 20280 20281 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 20282 //=== VK_EXT_full_screen_exclusive === 20283 20284 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> getSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const20285 PhysicalDevice::getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 20286 { 20287 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT && 20288 "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" ); 20289 20290 std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes; 20291 uint32_t presentModeCount; 20292 VULKAN_HPP_NAMESPACE::Result result; 20293 do 20294 { 20295 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20296 getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), 20297 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 20298 &presentModeCount, 20299 nullptr ) ); 20300 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount ) 20301 { 20302 presentModes.resize( presentModeCount ); 20303 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20304 getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), 20305 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 20306 &presentModeCount, 20307 reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) ); 20308 } 20309 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 20310 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); 20311 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); 20312 if ( presentModeCount < presentModes.size() ) 20313 { 20314 presentModes.resize( presentModeCount ); 20315 } 20316 return presentModes; 20317 } 20318 acquireFullScreenExclusiveModeEXT() const20319 VULKAN_HPP_INLINE void SwapchainKHR::acquireFullScreenExclusiveModeEXT() const 20320 { 20321 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireFullScreenExclusiveModeEXT && 20322 "Function <vkAcquireFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" ); 20323 20324 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20325 getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) ); 20326 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" ); 20327 } 20328 releaseFullScreenExclusiveModeEXT() const20329 VULKAN_HPP_INLINE void SwapchainKHR::releaseFullScreenExclusiveModeEXT() const 20330 { 20331 VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseFullScreenExclusiveModeEXT && 20332 "Function <vkReleaseFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" ); 20333 20334 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20335 getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) ); 20336 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" ); 20337 } 20338 20339 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR getGroupSurfacePresentModes2EXT(const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo) const20340 Device::getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const 20341 { 20342 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT && 20343 "Function <vkGetDeviceGroupSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" ); 20344 20345 VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR modes; 20346 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20347 getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT( static_cast<VkDevice>( m_device ), 20348 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ), 20349 reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) ); 20350 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); 20351 20352 return modes; 20353 } 20354 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 20355 20356 //=== VK_EXT_headless_surface === 20357 20358 VULKAN_HPP_NODISCARD 20359 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createHeadlessSurfaceEXT(VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const20360 Instance::createHeadlessSurfaceEXT( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo, 20361 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 20362 VULKAN_HPP_RAII_CREATE_NOEXCEPT 20363 { 20364 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 20365 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateHeadlessSurfaceEXT( 20366 static_cast<VkInstance>( m_instance ), 20367 reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ), 20368 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 20369 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 20370 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 20371 { 20372 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 20373 return VULKAN_HPP_UNEXPECTED( result ); 20374 # else 20375 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createHeadlessSurfaceEXT" ); 20376 # endif 20377 } 20378 20379 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 20380 } 20381 20382 //=== VK_KHR_buffer_device_address === 20383 20384 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress getBufferAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const20385 Device::getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 20386 { 20387 VULKAN_HPP_ASSERT( 20388 getDispatcher()->vkGetBufferDeviceAddressKHR && 20389 "Function <vkGetBufferDeviceAddressKHR> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); 20390 20391 VkDeviceAddress result = 20392 getDispatcher()->vkGetBufferDeviceAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); 20393 20394 return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); 20395 } 20396 20397 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t getBufferOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info) const20398 Device::getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 20399 { 20400 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR && 20401 "Function <vkGetBufferOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); 20402 20403 uint64_t result = 20404 getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) ); 20405 20406 return result; 20407 } 20408 20409 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t getMemoryOpaqueCaptureAddressKHR(const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info) const20410 Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT 20411 { 20412 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR && 20413 "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" ); 20414 20415 uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ), 20416 reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) ); 20417 20418 return result; 20419 } 20420 20421 //=== VK_EXT_line_rasterization === 20422 setLineStippleEXT(uint32_t lineStippleFactor,uint16_t lineStipplePattern) const20423 VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT 20424 { 20425 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT && 20426 "Function <vkCmdSetLineStippleEXT> requires <VK_EXT_line_rasterization> or <VK_KHR_line_rasterization> or <VK_VERSION_1_4>" ); 20427 20428 getDispatcher()->vkCmdSetLineStippleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); 20429 } 20430 20431 //=== VK_EXT_host_query_reset === 20432 resetEXT(uint32_t firstQuery,uint32_t queryCount) const20433 VULKAN_HPP_INLINE void QueryPool::resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT 20434 { 20435 VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPoolEXT && "Function <vkResetQueryPoolEXT> requires <VK_EXT_host_query_reset> or <VK_VERSION_1_2>" ); 20436 20437 getDispatcher()->vkResetQueryPoolEXT( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount ); 20438 } 20439 20440 //=== VK_EXT_extended_dynamic_state === 20441 setCullModeEXT(VULKAN_HPP_NAMESPACE::CullModeFlags cullMode) const20442 VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT 20443 { 20444 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullModeEXT && 20445 "Function <vkCmdSetCullModeEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20446 20447 getDispatcher()->vkCmdSetCullModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) ); 20448 } 20449 setFrontFaceEXT(VULKAN_HPP_NAMESPACE::FrontFace frontFace) const20450 VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT 20451 { 20452 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFaceEXT && 20453 "Function <vkCmdSetFrontFaceEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20454 20455 getDispatcher()->vkCmdSetFrontFaceEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) ); 20456 } 20457 setPrimitiveTopologyEXT(VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology) const20458 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT 20459 { 20460 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopologyEXT && 20461 "Function <vkCmdSetPrimitiveTopologyEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20462 20463 getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) ); 20464 } 20465 setViewportWithCountEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports) const20466 VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( 20467 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT 20468 { 20469 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCountEXT && 20470 "Function <vkCmdSetViewportWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20471 20472 getDispatcher()->vkCmdSetViewportWithCountEXT( 20473 static_cast<VkCommandBuffer>( m_commandBuffer ), viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) ); 20474 } 20475 20476 VULKAN_HPP_INLINE void setScissorWithCountEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors) const20477 CommandBuffer::setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT 20478 { 20479 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCountEXT && 20480 "Function <vkCmdSetScissorWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20481 20482 getDispatcher()->vkCmdSetScissorWithCountEXT( 20483 static_cast<VkCommandBuffer>( m_commandBuffer ), scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) ); 20484 } 20485 20486 VULKAN_HPP_INLINE void bindVertexBuffers2EXT(uint32_t firstBinding,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides) const20487 CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, 20488 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers, 20489 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets, 20490 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes, 20491 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides ) const 20492 { 20493 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2EXT && 20494 "Function <vkCmdBindVertexBuffers2EXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20495 # ifdef VULKAN_HPP_NO_EXCEPTIONS 20496 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); 20497 VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); 20498 VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); 20499 # else 20500 if ( buffers.size() != offsets.size() ) 20501 { 20502 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); 20503 } 20504 if ( !sizes.empty() && buffers.size() != sizes.size() ) 20505 { 20506 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); 20507 } 20508 if ( !strides.empty() && buffers.size() != strides.size() ) 20509 { 20510 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); 20511 } 20512 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 20513 20514 getDispatcher()->vkCmdBindVertexBuffers2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 20515 firstBinding, 20516 buffers.size(), 20517 reinterpret_cast<const VkBuffer *>( buffers.data() ), 20518 reinterpret_cast<const VkDeviceSize *>( offsets.data() ), 20519 reinterpret_cast<const VkDeviceSize *>( sizes.data() ), 20520 reinterpret_cast<const VkDeviceSize *>( strides.data() ) ); 20521 } 20522 setDepthTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable) const20523 VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT 20524 { 20525 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnableEXT && 20526 "Function <vkCmdSetDepthTestEnableEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20527 20528 getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) ); 20529 } 20530 setDepthWriteEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable) const20531 VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT 20532 { 20533 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnableEXT && 20534 "Function <vkCmdSetDepthWriteEnableEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20535 20536 getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) ); 20537 } 20538 setDepthCompareOpEXT(VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp) const20539 VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT 20540 { 20541 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOpEXT && 20542 "Function <vkCmdSetDepthCompareOpEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20543 20544 getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) ); 20545 } 20546 setDepthBoundsTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable) const20547 VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT 20548 { 20549 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT && 20550 "Function <vkCmdSetDepthBoundsTestEnableEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20551 20552 getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) ); 20553 } 20554 setStencilTestEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable) const20555 VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT 20556 { 20557 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnableEXT && 20558 "Function <vkCmdSetStencilTestEnableEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20559 20560 getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) ); 20561 } 20562 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) const20563 VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, 20564 VULKAN_HPP_NAMESPACE::StencilOp failOp, 20565 VULKAN_HPP_NAMESPACE::StencilOp passOp, 20566 VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, 20567 VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT 20568 { 20569 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOpEXT && 20570 "Function <vkCmdSetStencilOpEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 20571 20572 getDispatcher()->vkCmdSetStencilOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 20573 static_cast<VkStencilFaceFlags>( faceMask ), 20574 static_cast<VkStencilOp>( failOp ), 20575 static_cast<VkStencilOp>( passOp ), 20576 static_cast<VkStencilOp>( depthFailOp ), 20577 static_cast<VkCompareOp>( compareOp ) ); 20578 } 20579 20580 //=== VK_KHR_deferred_host_operations === 20581 20582 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 20583 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR>::Type createDeferredOperationKHR(VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const20584 Device::createDeferredOperationKHR( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 20585 VULKAN_HPP_RAII_CREATE_NOEXCEPT 20586 { 20587 VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation; 20588 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDeferredOperationKHR( 20589 static_cast<VkDevice>( m_device ), 20590 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 20591 reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) ); 20592 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 20593 { 20594 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 20595 return VULKAN_HPP_UNEXPECTED( result ); 20596 # else 20597 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDeferredOperationKHR" ); 20598 # endif 20599 } 20600 20601 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR( 20602 *this, *reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ), allocator ); 20603 } 20604 getMaxConcurrency() const20605 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT 20606 { 20607 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR && 20608 "Function <vkGetDeferredOperationMaxConcurrencyKHR> requires <VK_KHR_deferred_host_operations>" ); 20609 20610 uint32_t result = 20611 getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ); 20612 20613 return result; 20614 } 20615 getResult() const20616 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::getResult() const VULKAN_HPP_NOEXCEPT 20617 { 20618 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeferredOperationResultKHR && 20619 "Function <vkGetDeferredOperationResultKHR> requires <VK_KHR_deferred_host_operations>" ); 20620 20621 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20622 getDispatcher()->vkGetDeferredOperationResultKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ) ); 20623 20624 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 20625 } 20626 join() const20627 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::join() const 20628 { 20629 VULKAN_HPP_ASSERT( getDispatcher()->vkDeferredOperationJoinKHR && "Function <vkDeferredOperationJoinKHR> requires <VK_KHR_deferred_host_operations>" ); 20630 20631 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20632 getDispatcher()->vkDeferredOperationJoinKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ) ); 20633 VULKAN_HPP_NAMESPACE::detail::resultCheck( 20634 result, 20635 VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join", 20636 { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR, VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } ); 20637 20638 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 20639 } 20640 20641 //=== VK_KHR_pipeline_executable_properties === 20642 20643 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> getPipelineExecutablePropertiesKHR(const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo) const20644 Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo ) const 20645 { 20646 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineExecutablePropertiesKHR && 20647 "Function <vkGetPipelineExecutablePropertiesKHR> requires <VK_KHR_pipeline_executable_properties>" ); 20648 20649 std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> properties; 20650 uint32_t executableCount; 20651 VULKAN_HPP_NAMESPACE::Result result; 20652 do 20653 { 20654 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutablePropertiesKHR( 20655 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) ); 20656 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && executableCount ) 20657 { 20658 properties.resize( executableCount ); 20659 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20660 getDispatcher()->vkGetPipelineExecutablePropertiesKHR( static_cast<VkDevice>( m_device ), 20661 reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), 20662 &executableCount, 20663 reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) ); 20664 } 20665 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 20666 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); 20667 VULKAN_HPP_ASSERT( executableCount <= properties.size() ); 20668 if ( executableCount < properties.size() ) 20669 { 20670 properties.resize( executableCount ); 20671 } 20672 return properties; 20673 } 20674 20675 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> getPipelineExecutableStatisticsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo) const20676 Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const 20677 { 20678 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineExecutableStatisticsKHR && 20679 "Function <vkGetPipelineExecutableStatisticsKHR> requires <VK_KHR_pipeline_executable_properties>" ); 20680 20681 std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> statistics; 20682 uint32_t statisticCount; 20683 VULKAN_HPP_NAMESPACE::Result result; 20684 do 20685 { 20686 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutableStatisticsKHR( 20687 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &statisticCount, nullptr ) ); 20688 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && statisticCount ) 20689 { 20690 statistics.resize( statisticCount ); 20691 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20692 getDispatcher()->vkGetPipelineExecutableStatisticsKHR( static_cast<VkDevice>( m_device ), 20693 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), 20694 &statisticCount, 20695 reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) ); 20696 } 20697 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 20698 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); 20699 VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); 20700 if ( statisticCount < statistics.size() ) 20701 { 20702 statistics.resize( statisticCount ); 20703 } 20704 return statistics; 20705 } 20706 20707 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> getPipelineExecutableInternalRepresentationsKHR(const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo) const20708 Device::getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const 20709 { 20710 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR && 20711 "Function <vkGetPipelineExecutableInternalRepresentationsKHR> requires <VK_KHR_pipeline_executable_properties>" ); 20712 20713 std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> internalRepresentations; 20714 uint32_t internalRepresentationCount; 20715 VULKAN_HPP_NAMESPACE::Result result; 20716 do 20717 { 20718 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20719 getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( static_cast<VkDevice>( m_device ), 20720 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), 20721 &internalRepresentationCount, 20722 nullptr ) ); 20723 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && internalRepresentationCount ) 20724 { 20725 internalRepresentations.resize( internalRepresentationCount ); 20726 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( 20727 static_cast<VkDevice>( m_device ), 20728 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), 20729 &internalRepresentationCount, 20730 reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) ); 20731 } 20732 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 20733 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); 20734 VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); 20735 if ( internalRepresentationCount < internalRepresentations.size() ) 20736 { 20737 internalRepresentations.resize( internalRepresentationCount ); 20738 } 20739 return internalRepresentations; 20740 } 20741 20742 //=== VK_EXT_host_image_copy === 20743 copyMemoryToImageEXT(const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo) const20744 VULKAN_HPP_INLINE void Device::copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo & copyMemoryToImageInfo ) const 20745 { 20746 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToImageEXT && "Function <vkCopyMemoryToImageEXT> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" ); 20747 20748 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyMemoryToImageEXT( 20749 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyMemoryToImageInfo *>( ©MemoryToImageInfo ) ) ); 20750 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImageEXT" ); 20751 } 20752 copyImageToMemoryEXT(const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo) const20753 VULKAN_HPP_INLINE void Device::copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo & copyImageToMemoryInfo ) const 20754 { 20755 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToMemoryEXT && "Function <vkCopyImageToMemoryEXT> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" ); 20756 20757 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyImageToMemoryEXT( 20758 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToMemoryInfo *>( ©ImageToMemoryInfo ) ) ); 20759 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemoryEXT" ); 20760 } 20761 copyImageToImageEXT(const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo) const20762 VULKAN_HPP_INLINE void Device::copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfo & copyImageToImageInfo ) const 20763 { 20764 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToImageEXT && "Function <vkCopyImageToImageEXT> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" ); 20765 20766 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyImageToImageEXT( 20767 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToImageInfo *>( ©ImageToImageInfo ) ) ); 20768 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImageEXT" ); 20769 } 20770 20771 VULKAN_HPP_INLINE void transitionImageLayoutEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions) const20772 Device::transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo> const & transitions ) const 20773 { 20774 VULKAN_HPP_ASSERT( getDispatcher()->vkTransitionImageLayoutEXT && 20775 "Function <vkTransitionImageLayoutEXT> requires <VK_EXT_host_image_copy> or <VK_VERSION_1_4>" ); 20776 20777 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkTransitionImageLayoutEXT( 20778 static_cast<VkDevice>( m_device ), transitions.size(), reinterpret_cast<const VkHostImageLayoutTransitionInfo *>( transitions.data() ) ) ); 20779 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayoutEXT" ); 20780 } 20781 20782 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2 getSubresourceLayout2EXT(const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource) const20783 Image::getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT 20784 { 20785 VULKAN_HPP_ASSERT( 20786 getDispatcher()->vkGetImageSubresourceLayout2EXT && 20787 "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 20788 20789 VULKAN_HPP_NAMESPACE::SubresourceLayout2 layout; 20790 getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast<VkDevice>( m_device ), 20791 static_cast<VkImage>( m_image ), 20792 reinterpret_cast<const VkImageSubresource2 *>( &subresource ), 20793 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 20794 20795 return layout; 20796 } 20797 20798 template <typename X, typename Y, typename... Z> 20799 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getSubresourceLayout2EXT(const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource) const20800 Image::getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT 20801 { 20802 VULKAN_HPP_ASSERT( 20803 getDispatcher()->vkGetImageSubresourceLayout2EXT && 20804 "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 20805 20806 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 20807 VULKAN_HPP_NAMESPACE::SubresourceLayout2 & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2>(); 20808 getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast<VkDevice>( m_device ), 20809 static_cast<VkImage>( m_image ), 20810 reinterpret_cast<const VkImageSubresource2 *>( &subresource ), 20811 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 20812 20813 return structureChain; 20814 } 20815 20816 //=== VK_KHR_map_memory2 === 20817 mapMemory2KHR(const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo) const20818 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * Device::mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfo & memoryMapInfo ) const 20819 { 20820 VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory2KHR && "Function <vkMapMemory2KHR> requires <VK_KHR_map_memory2> or <VK_VERSION_1_4>" ); 20821 20822 void * pData; 20823 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20824 getDispatcher()->vkMapMemory2KHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryMapInfo *>( &memoryMapInfo ), &pData ) ); 20825 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2KHR" ); 20826 20827 return pData; 20828 } 20829 unmapMemory2KHR(const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo) const20830 VULKAN_HPP_INLINE void Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfo & memoryUnmapInfo ) const 20831 { 20832 VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory2KHR && "Function <vkUnmapMemory2KHR> requires <VK_KHR_map_memory2> or <VK_VERSION_1_4>" ); 20833 20834 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20835 getDispatcher()->vkUnmapMemory2KHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryUnmapInfo *>( &memoryUnmapInfo ) ) ); 20836 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2KHR" ); 20837 } 20838 20839 //=== VK_EXT_swapchain_maintenance1 === 20840 releaseSwapchainImagesEXT(const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo) const20841 VULKAN_HPP_INLINE void Device::releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo ) const 20842 { 20843 VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseSwapchainImagesEXT && "Function <vkReleaseSwapchainImagesEXT> requires <VK_EXT_swapchain_maintenance1>" ); 20844 20845 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkReleaseSwapchainImagesEXT( 20846 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkReleaseSwapchainImagesInfoEXT *>( &releaseInfo ) ) ); 20847 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseSwapchainImagesEXT" ); 20848 } 20849 20850 //=== VK_NV_device_generated_commands === 20851 20852 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info) const20853 Device::getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT 20854 { 20855 VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && 20856 "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" ); 20857 20858 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 20859 getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast<VkDevice>( m_device ), 20860 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ), 20861 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 20862 20863 return memoryRequirements; 20864 } 20865 20866 template <typename X, typename Y, typename... Z> 20867 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info) const20868 Device::getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT 20869 { 20870 VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && 20871 "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" ); 20872 20873 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 20874 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 20875 getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast<VkDevice>( m_device ), 20876 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ), 20877 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 20878 20879 return structureChain; 20880 } 20881 20882 VULKAN_HPP_INLINE void preprocessGeneratedCommandsNV(const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo) const20883 CommandBuffer::preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT 20884 { 20885 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPreprocessGeneratedCommandsNV && 20886 "Function <vkCmdPreprocessGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" ); 20887 20888 getDispatcher()->vkCmdPreprocessGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 20889 reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) ); 20890 } 20891 20892 VULKAN_HPP_INLINE void executeGeneratedCommandsNV(VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo) const20893 CommandBuffer::executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed, 20894 const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT 20895 { 20896 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdExecuteGeneratedCommandsNV && 20897 "Function <vkCmdExecuteGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" ); 20898 20899 getDispatcher()->vkCmdExecuteGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 20900 static_cast<VkBool32>( isPreprocessed ), 20901 reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) ); 20902 } 20903 bindPipelineShaderGroupNV(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::Pipeline pipeline,uint32_t groupIndex) const20904 VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 20905 VULKAN_HPP_NAMESPACE::Pipeline pipeline, 20906 uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT 20907 { 20908 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindPipelineShaderGroupNV && 20909 "Function <vkCmdBindPipelineShaderGroupNV> requires <VK_NV_device_generated_commands>" ); 20910 20911 getDispatcher()->vkCmdBindPipelineShaderGroupNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 20912 static_cast<VkPipelineBindPoint>( pipelineBindPoint ), 20913 static_cast<VkPipeline>( pipeline ), 20914 groupIndex ); 20915 } 20916 20917 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 20918 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV>::Type createIndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const20919 Device::createIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo, 20920 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 20921 VULKAN_HPP_RAII_CREATE_NOEXCEPT 20922 { 20923 VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout; 20924 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateIndirectCommandsLayoutNV( 20925 static_cast<VkDevice>( m_device ), 20926 reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ), 20927 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 20928 reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) ); 20929 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 20930 { 20931 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 20932 return VULKAN_HPP_UNEXPECTED( result ); 20933 # else 20934 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createIndirectCommandsLayoutNV" ); 20935 # endif 20936 } 20937 20938 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV( 20939 *this, *reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ), allocator ); 20940 } 20941 20942 //=== VK_EXT_depth_bias_control === 20943 setDepthBias2EXT(const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo) const20944 VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo ) const VULKAN_HPP_NOEXCEPT 20945 { 20946 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBias2EXT && "Function <vkCmdSetDepthBias2EXT> requires <VK_EXT_depth_bias_control>" ); 20947 20948 getDispatcher()->vkCmdSetDepthBias2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDepthBiasInfoEXT *>( &depthBiasInfo ) ); 20949 } 20950 20951 //=== VK_EXT_acquire_drm_display === 20952 acquireDrmDisplayEXT(int32_t drmFd,VULKAN_HPP_NAMESPACE::DisplayKHR display) const20953 VULKAN_HPP_INLINE void PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const 20954 { 20955 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireDrmDisplayEXT && "Function <vkAcquireDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" ); 20956 20957 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 20958 getDispatcher()->vkAcquireDrmDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), drmFd, static_cast<VkDisplayKHR>( display ) ) ); 20959 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); 20960 } 20961 20962 VULKAN_HPP_NODISCARD 20963 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type getDrmDisplayEXT(int32_t drmFd,uint32_t connectorId) const20964 PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 20965 { 20966 VULKAN_HPP_NAMESPACE::DisplayKHR display; 20967 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDrmDisplayEXT( 20968 static_cast<VkPhysicalDevice>( m_physicalDevice ), drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); 20969 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 20970 { 20971 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 20972 return VULKAN_HPP_UNEXPECTED( result ); 20973 # else 20974 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::getDrmDisplayEXT" ); 20975 # endif 20976 } 20977 20978 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, *reinterpret_cast<VkDisplayKHR *>( &display ) ); 20979 } 20980 20981 //=== VK_EXT_private_data === 20982 20983 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 20984 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot>::Type createPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const20985 Device::createPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo, 20986 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 20987 VULKAN_HPP_RAII_CREATE_NOEXCEPT 20988 { 20989 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; 20990 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePrivateDataSlotEXT( 20991 static_cast<VkDevice>( m_device ), 20992 reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ), 20993 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 20994 reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) ); 20995 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 20996 { 20997 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 20998 return VULKAN_HPP_UNEXPECTED( result ); 20999 # else 21000 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPrivateDataSlotEXT" ); 21001 # endif 21002 } 21003 21004 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot( *this, *reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ), allocator ); 21005 } 21006 destroyPrivateDataSlotEXT(VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const21007 VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, 21008 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT 21009 { 21010 VULKAN_HPP_ASSERT( getDispatcher()->vkDestroyPrivateDataSlotEXT && 21011 "Function <vkDestroyPrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); 21012 21013 getDispatcher()->vkDestroyPrivateDataSlotEXT( 21014 static_cast<VkDevice>( m_device ), 21015 static_cast<VkPrivateDataSlot>( privateDataSlot ), 21016 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); 21017 } 21018 setPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType_,uint64_t objectHandle,VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,uint64_t data) const21019 VULKAN_HPP_INLINE void Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 21020 uint64_t objectHandle, 21021 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, 21022 uint64_t data ) const 21023 { 21024 VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateDataEXT && "Function <vkSetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); 21025 21026 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetPrivateDataEXT( 21027 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) ); 21028 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); 21029 } 21030 getPrivateDataEXT(VULKAN_HPP_NAMESPACE::ObjectType objectType_,uint64_t objectHandle,VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot) const21031 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_, 21032 uint64_t objectHandle, 21033 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT 21034 { 21035 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateDataEXT && "Function <vkGetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" ); 21036 21037 uint64_t data; 21038 getDispatcher()->vkGetPrivateDataEXT( 21039 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data ); 21040 21041 return data; 21042 } 21043 21044 //=== VK_KHR_video_encode_queue === 21045 getVideoEncodeQualityLevelPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo) const21046 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( 21047 const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const 21048 { 21049 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && 21050 "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" ); 21051 21052 VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties; 21053 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( 21054 static_cast<VkPhysicalDevice>( m_physicalDevice ), 21055 reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( &qualityLevelInfo ), 21056 reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( &qualityLevelProperties ) ) ); 21057 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); 21058 21059 return qualityLevelProperties; 21060 } 21061 21062 template <typename X, typename Y, typename... Z> getVideoEncodeQualityLevelPropertiesKHR(const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo) const21063 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( 21064 const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const 21065 { 21066 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && 21067 "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" ); 21068 21069 StructureChain<X, Y, Z...> structureChain; 21070 VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties = 21071 structureChain.template get<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>(); 21072 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( 21073 static_cast<VkPhysicalDevice>( m_physicalDevice ), 21074 reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( &qualityLevelInfo ), 21075 reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( &qualityLevelProperties ) ) ); 21076 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); 21077 21078 return structureChain; 21079 } 21080 21081 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t>> getEncodedVideoSessionParametersKHR(const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo) const21082 Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const 21083 { 21084 VULKAN_HPP_ASSERT( getDispatcher()->vkGetEncodedVideoSessionParametersKHR && 21085 "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" ); 21086 21087 std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t>> data_; 21088 VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; 21089 std::vector<uint8_t> & data = data_.second; 21090 size_t dataSize; 21091 VULKAN_HPP_NAMESPACE::Result result; 21092 do 21093 { 21094 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( 21095 static_cast<VkDevice>( m_device ), 21096 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), 21097 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), 21098 &dataSize, 21099 nullptr ) ); 21100 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) 21101 { 21102 data.resize( dataSize ); 21103 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( 21104 static_cast<VkDevice>( m_device ), 21105 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), 21106 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), 21107 &dataSize, 21108 reinterpret_cast<void *>( data.data() ) ) ); 21109 } 21110 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 21111 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); 21112 21113 return data_; 21114 } 21115 21116 template <typename X, typename Y, typename... Z> 21117 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t>> getEncodedVideoSessionParametersKHR(const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo) const21118 Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const 21119 { 21120 VULKAN_HPP_ASSERT( getDispatcher()->vkGetEncodedVideoSessionParametersKHR && 21121 "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" ); 21122 21123 std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t>> data_; 21124 VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = 21125 data_.first.template get<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR>(); 21126 std::vector<uint8_t> & data = data_.second; 21127 size_t dataSize; 21128 VULKAN_HPP_NAMESPACE::Result result; 21129 do 21130 { 21131 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( 21132 static_cast<VkDevice>( m_device ), 21133 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), 21134 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), 21135 &dataSize, 21136 nullptr ) ); 21137 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) 21138 { 21139 data.resize( dataSize ); 21140 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( 21141 static_cast<VkDevice>( m_device ), 21142 reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ), 21143 reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ), 21144 &dataSize, 21145 reinterpret_cast<void *>( data.data() ) ) ); 21146 } 21147 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 21148 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); 21149 21150 return data_; 21151 } 21152 encodeVideoKHR(const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo) const21153 VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT 21154 { 21155 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEncodeVideoKHR && "Function <vkCmdEncodeVideoKHR> requires <VK_KHR_video_encode_queue>" ); 21156 21157 getDispatcher()->vkCmdEncodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) ); 21158 } 21159 21160 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 21161 //=== VK_NV_cuda_kernel_launch === 21162 21163 VULKAN_HPP_NODISCARD 21164 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV>::Type createCudaModuleNV(VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const21165 Device::createCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & createInfo, 21166 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 21167 VULKAN_HPP_RAII_CREATE_NOEXCEPT 21168 { 21169 VULKAN_HPP_NAMESPACE::CudaModuleNV module; 21170 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCudaModuleNV( 21171 static_cast<VkDevice>( m_device ), 21172 reinterpret_cast<const VkCudaModuleCreateInfoNV *>( &createInfo ), 21173 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 21174 reinterpret_cast<VkCudaModuleNV *>( &module ) ) ); 21175 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 21176 { 21177 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 21178 return VULKAN_HPP_UNEXPECTED( result ); 21179 # else 21180 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCudaModuleNV" ); 21181 # endif 21182 } 21183 21184 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV( *this, *reinterpret_cast<VkCudaModuleNV *>( &module ), allocator ); 21185 } 21186 getCache() const21187 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> CudaModuleNV::getCache() const 21188 { 21189 VULKAN_HPP_ASSERT( getDispatcher()->vkGetCudaModuleCacheNV && "Function <vkGetCudaModuleCacheNV> requires <VK_NV_cuda_kernel_launch>" ); 21190 21191 std::vector<uint8_t> cacheData; 21192 size_t cacheSize; 21193 VULKAN_HPP_NAMESPACE::Result result; 21194 do 21195 { 21196 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 21197 getDispatcher()->vkGetCudaModuleCacheNV( static_cast<VkDevice>( m_device ), static_cast<VkCudaModuleNV>( m_module ), &cacheSize, nullptr ) ); 21198 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && cacheSize ) 21199 { 21200 cacheData.resize( cacheSize ); 21201 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCudaModuleCacheNV( 21202 static_cast<VkDevice>( m_device ), static_cast<VkCudaModuleNV>( m_module ), &cacheSize, reinterpret_cast<void *>( cacheData.data() ) ) ); 21203 } 21204 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 21205 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CudaModuleNV::getCache" ); 21206 VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() ); 21207 if ( cacheSize < cacheData.size() ) 21208 { 21209 cacheData.resize( cacheSize ); 21210 } 21211 return cacheData; 21212 } 21213 21214 VULKAN_HPP_NODISCARD 21215 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV>::Type createCudaFunctionNV(VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const21216 Device::createCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & createInfo, 21217 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 21218 VULKAN_HPP_RAII_CREATE_NOEXCEPT 21219 { 21220 VULKAN_HPP_NAMESPACE::CudaFunctionNV function; 21221 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCudaFunctionNV( 21222 static_cast<VkDevice>( m_device ), 21223 reinterpret_cast<const VkCudaFunctionCreateInfoNV *>( &createInfo ), 21224 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 21225 reinterpret_cast<VkCudaFunctionNV *>( &function ) ) ); 21226 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 21227 { 21228 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 21229 return VULKAN_HPP_UNEXPECTED( result ); 21230 # else 21231 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCudaFunctionNV" ); 21232 # endif 21233 } 21234 21235 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV( *this, *reinterpret_cast<VkCudaFunctionNV *>( &function ), allocator ); 21236 } 21237 cudaLaunchKernelNV(const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo) const21238 VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo ) const VULKAN_HPP_NOEXCEPT 21239 { 21240 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCudaLaunchKernelNV && "Function <vkCmdCudaLaunchKernelNV> requires <VK_NV_cuda_kernel_launch>" ); 21241 21242 getDispatcher()->vkCmdCudaLaunchKernelNV( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCudaLaunchInfoNV *>( &launchInfo ) ); 21243 } 21244 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 21245 21246 # if defined( VK_USE_PLATFORM_METAL_EXT ) 21247 //=== VK_EXT_metal_objects === 21248 exportMetalObjectsEXT() const21249 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT 21250 { 21251 VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" ); 21252 21253 VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo; 21254 getDispatcher()->vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) ); 21255 21256 return metalObjectsInfo; 21257 } 21258 21259 template <typename X, typename Y, typename... Z> exportMetalObjectsEXT() const21260 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT 21261 { 21262 VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" ); 21263 21264 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 21265 VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo = structureChain.template get<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>(); 21266 getDispatcher()->vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) ); 21267 21268 return structureChain; 21269 } 21270 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 21271 21272 //=== VK_KHR_synchronization2 === 21273 setEvent2KHR(VULKAN_HPP_NAMESPACE::Event event,const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo) const21274 VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, 21275 const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 21276 { 21277 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2KHR && "Function <vkCmdSetEvent2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 21278 21279 getDispatcher()->vkCmdSetEvent2KHR( 21280 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) ); 21281 } 21282 resetEvent2KHR(VULKAN_HPP_NAMESPACE::Event event,VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask) const21283 VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, 21284 VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT 21285 { 21286 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2KHR && "Function <vkCmdResetEvent2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 21287 21288 getDispatcher()->vkCmdResetEvent2KHR( 21289 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) ); 21290 } 21291 21292 VULKAN_HPP_INLINE void waitEvents2KHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos) const21293 CommandBuffer::waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events, 21294 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos ) const 21295 { 21296 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2KHR && "Function <vkCmdWaitEvents2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 21297 # ifdef VULKAN_HPP_NO_EXCEPTIONS 21298 VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); 21299 # else 21300 if ( events.size() != dependencyInfos.size() ) 21301 { 21302 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" ); 21303 } 21304 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 21305 21306 getDispatcher()->vkCmdWaitEvents2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 21307 events.size(), 21308 reinterpret_cast<const VkEvent *>( events.data() ), 21309 reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) ); 21310 } 21311 pipelineBarrier2KHR(const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo) const21312 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT 21313 { 21314 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2KHR && 21315 "Function <vkCmdPipelineBarrier2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 21316 21317 getDispatcher()->vkCmdPipelineBarrier2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 21318 reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) ); 21319 } 21320 writeTimestamp2KHR(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t query) const21321 VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, 21322 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 21323 uint32_t query ) const VULKAN_HPP_NOEXCEPT 21324 { 21325 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2KHR && 21326 "Function <vkCmdWriteTimestamp2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 21327 21328 getDispatcher()->vkCmdWriteTimestamp2KHR( 21329 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query ); 21330 } 21331 submit2KHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,VULKAN_HPP_NAMESPACE::Fence fence) const21332 VULKAN_HPP_INLINE void Queue::submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits, 21333 VULKAN_HPP_NAMESPACE::Fence fence ) const 21334 { 21335 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2KHR && "Function <vkQueueSubmit2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" ); 21336 21337 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSubmit2KHR( 21338 static_cast<VkQueue>( m_queue ), submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) ); 21339 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" ); 21340 } 21341 writeBufferMarker2AMD(VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,VULKAN_HPP_NAMESPACE::Buffer dstBuffer,VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,uint32_t marker) const21342 VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, 21343 VULKAN_HPP_NAMESPACE::Buffer dstBuffer, 21344 VULKAN_HPP_NAMESPACE::DeviceSize dstOffset, 21345 uint32_t marker ) const VULKAN_HPP_NOEXCEPT 21346 { 21347 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarker2AMD && "Function <vkCmdWriteBufferMarker2AMD> requires <VK_KHR_synchronization2>" ); 21348 21349 getDispatcher()->vkCmdWriteBufferMarker2AMD( static_cast<VkCommandBuffer>( m_commandBuffer ), 21350 static_cast<VkPipelineStageFlags2>( stage ), 21351 static_cast<VkBuffer>( dstBuffer ), 21352 static_cast<VkDeviceSize>( dstOffset ), 21353 marker ); 21354 } 21355 getCheckpointData2NV() const21356 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> Queue::getCheckpointData2NV() const 21357 { 21358 VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV && "Function <vkGetQueueCheckpointData2NV> requires <VK_KHR_synchronization2>" ); 21359 21360 std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> checkpointData; 21361 uint32_t checkpointDataCount; 21362 getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr ); 21363 checkpointData.resize( checkpointDataCount ); 21364 getDispatcher()->vkGetQueueCheckpointData2NV( 21365 static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) ); 21366 21367 VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); 21368 if ( checkpointDataCount < checkpointData.size() ) 21369 { 21370 checkpointData.resize( checkpointDataCount ); 21371 } 21372 return checkpointData; 21373 } 21374 21375 //=== VK_EXT_descriptor_buffer === 21376 getSizeEXT() const21377 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize DescriptorSetLayout::getSizeEXT() const VULKAN_HPP_NOEXCEPT 21378 { 21379 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSizeEXT && "Function <vkGetDescriptorSetLayoutSizeEXT> requires <VK_EXT_descriptor_buffer>" ); 21380 21381 VULKAN_HPP_NAMESPACE::DeviceSize layoutSizeInBytes; 21382 getDispatcher()->vkGetDescriptorSetLayoutSizeEXT( static_cast<VkDevice>( m_device ), 21383 static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ), 21384 reinterpret_cast<VkDeviceSize *>( &layoutSizeInBytes ) ); 21385 21386 return layoutSizeInBytes; 21387 } 21388 21389 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize getBindingOffsetEXT(uint32_t binding) const21390 DescriptorSetLayout::getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT 21391 { 21392 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutBindingOffsetEXT && 21393 "Function <vkGetDescriptorSetLayoutBindingOffsetEXT> requires <VK_EXT_descriptor_buffer>" ); 21394 21395 VULKAN_HPP_NAMESPACE::DeviceSize offset; 21396 getDispatcher()->vkGetDescriptorSetLayoutBindingOffsetEXT( 21397 static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ), binding, reinterpret_cast<VkDeviceSize *>( &offset ) ); 21398 21399 return offset; 21400 } 21401 getDescriptorEXT(const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,size_t dataSize,void * pDescriptor) const21402 VULKAN_HPP_INLINE void Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, 21403 size_t dataSize, 21404 void * pDescriptor ) const VULKAN_HPP_NOEXCEPT 21405 { 21406 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" ); 21407 21408 getDispatcher()->vkGetDescriptorEXT( 21409 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), dataSize, pDescriptor ); 21410 } 21411 21412 template <typename DescriptorType> 21413 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorType getDescriptorEXT(const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo) const21414 Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT 21415 { 21416 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" ); 21417 21418 DescriptorType descriptor; 21419 getDispatcher()->vkGetDescriptorEXT( static_cast<VkDevice>( m_device ), 21420 reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), 21421 sizeof( DescriptorType ), 21422 reinterpret_cast<void *>( &descriptor ) ); 21423 21424 return descriptor; 21425 } 21426 bindDescriptorBuffersEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos) const21427 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT( 21428 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos ) const VULKAN_HPP_NOEXCEPT 21429 { 21430 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBuffersEXT && "Function <vkCmdBindDescriptorBuffersEXT> requires <VK_EXT_descriptor_buffer>" ); 21431 21432 getDispatcher()->vkCmdBindDescriptorBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 21433 bindingInfos.size(), 21434 reinterpret_cast<const VkDescriptorBufferBindingInfoEXT *>( bindingInfos.data() ) ); 21435 } 21436 21437 VULKAN_HPP_INLINE void setDescriptorBufferOffsetsEXT(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t firstSet,VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets) const21438 CommandBuffer::setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 21439 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 21440 uint32_t firstSet, 21441 VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices, 21442 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const 21443 { 21444 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDescriptorBufferOffsetsEXT && 21445 "Function <vkCmdSetDescriptorBufferOffsetsEXT> requires <VK_EXT_descriptor_buffer>" ); 21446 # ifdef VULKAN_HPP_NO_EXCEPTIONS 21447 VULKAN_HPP_ASSERT( bufferIndices.size() == offsets.size() ); 21448 # else 21449 if ( bufferIndices.size() != offsets.size() ) 21450 { 21451 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setDescriptorBufferOffsetsEXT: bufferIndices.size() != offsets.size()" ); 21452 } 21453 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 21454 21455 getDispatcher()->vkCmdSetDescriptorBufferOffsetsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 21456 static_cast<VkPipelineBindPoint>( pipelineBindPoint ), 21457 static_cast<VkPipelineLayout>( layout ), 21458 firstSet, 21459 bufferIndices.size(), 21460 bufferIndices.data(), 21461 reinterpret_cast<const VkDeviceSize *>( offsets.data() ) ); 21462 } 21463 bindDescriptorBufferEmbeddedSamplersEXT(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::PipelineLayout layout,uint32_t set) const21464 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 21465 VULKAN_HPP_NAMESPACE::PipelineLayout layout, 21466 uint32_t set ) const VULKAN_HPP_NOEXCEPT 21467 { 21468 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT && 21469 "Function <vkCmdBindDescriptorBufferEmbeddedSamplersEXT> requires <VK_EXT_descriptor_buffer>" ); 21470 21471 getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT( 21472 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set ); 21473 } 21474 21475 template <typename DataType> 21476 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType getBufferOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info) const21477 Device::getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info ) const 21478 { 21479 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferOpaqueCaptureDescriptorDataEXT && 21480 "Function <vkGetBufferOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); 21481 21482 DataType data; 21483 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetBufferOpaqueCaptureDescriptorDataEXT( 21484 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); 21485 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" ); 21486 21487 return data; 21488 } 21489 21490 template <typename DataType> 21491 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType getImageOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info) const21492 Device::getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info ) const 21493 { 21494 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageOpaqueCaptureDescriptorDataEXT && 21495 "Function <vkGetImageOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); 21496 21497 DataType data; 21498 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageOpaqueCaptureDescriptorDataEXT( 21499 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); 21500 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" ); 21501 21502 return data; 21503 } 21504 21505 template <typename DataType> 21506 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType getImageViewOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info) const21507 Device::getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info ) const 21508 { 21509 VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewOpaqueCaptureDescriptorDataEXT && 21510 "Function <vkGetImageViewOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); 21511 21512 DataType data; 21513 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageViewOpaqueCaptureDescriptorDataEXT( 21514 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); 21515 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" ); 21516 21517 return data; 21518 } 21519 21520 template <typename DataType> 21521 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType getSamplerOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info) const21522 Device::getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info ) const 21523 { 21524 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSamplerOpaqueCaptureDescriptorDataEXT && 21525 "Function <vkGetSamplerOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); 21526 21527 DataType data; 21528 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSamplerOpaqueCaptureDescriptorDataEXT( 21529 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); 21530 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" ); 21531 21532 return data; 21533 } 21534 21535 template <typename DataType> getAccelerationStructureOpaqueCaptureDescriptorDataEXT(const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info) const21536 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( 21537 const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const 21538 { 21539 VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT && 21540 "Function <vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" ); 21541 21542 DataType data; 21543 VULKAN_HPP_NAMESPACE::Result result = 21544 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( 21545 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT *>( &info ), &data ) ); 21546 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" ); 21547 21548 return data; 21549 } 21550 21551 //=== VK_NV_fragment_shading_rate_enums === 21552 21553 VULKAN_HPP_INLINE void setFragmentShadingRateEnumNV(VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate,const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2]) const21554 CommandBuffer::setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate, 21555 const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT 21556 { 21557 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFragmentShadingRateEnumNV && 21558 "Function <vkCmdSetFragmentShadingRateEnumNV> requires <VK_NV_fragment_shading_rate_enums>" ); 21559 21560 getDispatcher()->vkCmdSetFragmentShadingRateEnumNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 21561 static_cast<VkFragmentShadingRateNV>( shadingRate ), 21562 reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) ); 21563 } 21564 21565 //=== VK_EXT_mesh_shader === 21566 drawMeshTasksEXT(uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const21567 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 21568 { 21569 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksEXT && "Function <vkCmdDrawMeshTasksEXT> requires <VK_EXT_mesh_shader>" ); 21570 21571 getDispatcher()->vkCmdDrawMeshTasksEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); 21572 } 21573 drawMeshTasksIndirectEXT(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,uint32_t drawCount,uint32_t stride) const21574 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, 21575 VULKAN_HPP_NAMESPACE::DeviceSize offset, 21576 uint32_t drawCount, 21577 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 21578 { 21579 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectEXT && "Function <vkCmdDrawMeshTasksIndirectEXT> requires <VK_EXT_mesh_shader>" ); 21580 21581 getDispatcher()->vkCmdDrawMeshTasksIndirectEXT( 21582 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride ); 21583 } 21584 drawMeshTasksIndirectCountEXT(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) const21585 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, 21586 VULKAN_HPP_NAMESPACE::DeviceSize offset, 21587 VULKAN_HPP_NAMESPACE::Buffer countBuffer, 21588 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset, 21589 uint32_t maxDrawCount, 21590 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 21591 { 21592 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT && "Function <vkCmdDrawMeshTasksIndirectCountEXT> requires <VK_EXT_mesh_shader>" ); 21593 21594 getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 21595 static_cast<VkBuffer>( buffer ), 21596 static_cast<VkDeviceSize>( offset ), 21597 static_cast<VkBuffer>( countBuffer ), 21598 static_cast<VkDeviceSize>( countBufferOffset ), 21599 maxDrawCount, 21600 stride ); 21601 } 21602 21603 //=== VK_KHR_copy_commands2 === 21604 copyBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo) const21605 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT 21606 { 21607 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2KHR && "Function <vkCmdCopyBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 21608 21609 getDispatcher()->vkCmdCopyBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( ©BufferInfo ) ); 21610 } 21611 copyImage2KHR(const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo) const21612 VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT 21613 { 21614 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2KHR && "Function <vkCmdCopyImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 21615 21616 getDispatcher()->vkCmdCopyImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( ©ImageInfo ) ); 21617 } 21618 21619 VULKAN_HPP_INLINE void copyBufferToImage2KHR(const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo) const21620 CommandBuffer::copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT 21621 { 21622 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2KHR && 21623 "Function <vkCmdCopyBufferToImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 21624 21625 getDispatcher()->vkCmdCopyBufferToImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 21626 reinterpret_cast<const VkCopyBufferToImageInfo2 *>( ©BufferToImageInfo ) ); 21627 } 21628 21629 VULKAN_HPP_INLINE void copyImageToBuffer2KHR(const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo) const21630 CommandBuffer::copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT 21631 { 21632 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2KHR && 21633 "Function <vkCmdCopyImageToBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 21634 21635 getDispatcher()->vkCmdCopyImageToBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 21636 reinterpret_cast<const VkCopyImageToBufferInfo2 *>( ©ImageToBufferInfo ) ); 21637 } 21638 blitImage2KHR(const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo) const21639 VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT 21640 { 21641 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2KHR && "Function <vkCmdBlitImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 21642 21643 getDispatcher()->vkCmdBlitImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) ); 21644 } 21645 resolveImage2KHR(const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo) const21646 VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT 21647 { 21648 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2KHR && "Function <vkCmdResolveImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" ); 21649 21650 getDispatcher()->vkCmdResolveImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 21651 reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) ); 21652 } 21653 21654 //=== VK_EXT_device_fault === 21655 template <typename Dispatch> getFaultInfoEXT(VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts,VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT * pFaultInfo,Dispatch const & d) const21656 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultInfoEXT( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT * pFaultCounts, 21657 VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT * pFaultInfo, 21658 Dispatch const & d ) const VULKAN_HPP_NOEXCEPT 21659 { 21660 VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); 21661 return static_cast<Result>( d.vkGetDeviceFaultInfoEXT( 21662 m_device, reinterpret_cast<VkDeviceFaultCountsEXT *>( pFaultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( pFaultInfo ) ) ); 21663 } 21664 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 21665 //=== VK_NV_acquire_winrt_display === 21666 acquireWinrtNV() const21667 VULKAN_HPP_INLINE void DisplayKHR::acquireWinrtNV() const 21668 { 21669 VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireWinrtDisplayNV && "Function <vkAcquireWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" ); 21670 21671 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 21672 getDispatcher()->vkAcquireWinrtDisplayNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) ) ); 21673 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" ); 21674 } 21675 21676 VULKAN_HPP_NODISCARD 21677 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type getWinrtDisplayNV(uint32_t deviceRelativeId) const21678 PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 21679 { 21680 VULKAN_HPP_NAMESPACE::DisplayKHR display; 21681 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetWinrtDisplayNV( 21682 static_cast<VkPhysicalDevice>( m_physicalDevice ), deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) ); 21683 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 21684 { 21685 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 21686 return VULKAN_HPP_UNEXPECTED( result ); 21687 # else 21688 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::getWinrtDisplayNV" ); 21689 # endif 21690 } 21691 21692 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, *reinterpret_cast<VkDisplayKHR *>( &display ) ); 21693 } 21694 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 21695 21696 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 21697 //=== VK_EXT_directfb_surface === 21698 21699 VULKAN_HPP_NODISCARD 21700 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createDirectFBSurfaceEXT(VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const21701 Instance::createDirectFBSurfaceEXT( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo, 21702 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 21703 VULKAN_HPP_RAII_CREATE_NOEXCEPT 21704 { 21705 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 21706 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDirectFBSurfaceEXT( 21707 static_cast<VkInstance>( m_instance ), 21708 reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ), 21709 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 21710 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 21711 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 21712 { 21713 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 21714 return VULKAN_HPP_UNEXPECTED( result ); 21715 # else 21716 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createDirectFBSurfaceEXT" ); 21717 # endif 21718 } 21719 21720 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 21721 } 21722 21723 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT(uint32_t queueFamilyIndex,IDirectFB & dfb) const21724 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT 21725 { 21726 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT && 21727 "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> requires <VK_EXT_directfb_surface>" ); 21728 21729 VkBool32 result = 21730 getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dfb ); 21731 21732 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); 21733 } 21734 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 21735 21736 //=== VK_EXT_vertex_input_dynamic_state === 21737 setVertexInputEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions) const21738 VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( 21739 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions, 21740 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions ) const 21741 VULKAN_HPP_NOEXCEPT 21742 { 21743 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetVertexInputEXT && 21744 "Function <vkCmdSetVertexInputEXT> requires <VK_EXT_shader_object> or <VK_EXT_vertex_input_dynamic_state>" ); 21745 21746 getDispatcher()->vkCmdSetVertexInputEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 21747 vertexBindingDescriptions.size(), 21748 reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ), 21749 vertexAttributeDescriptions.size(), 21750 reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) ); 21751 } 21752 21753 # if defined( VK_USE_PLATFORM_FUCHSIA ) 21754 //=== VK_FUCHSIA_external_memory === 21755 21756 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t getMemoryZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo) const21757 Device::getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const 21758 { 21759 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA && "Function <vkGetMemoryZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_memory>" ); 21760 21761 zx_handle_t zirconHandle; 21762 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA( 21763 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) ); 21764 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); 21765 21766 return zirconHandle; 21767 } 21768 21769 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA getMemoryZirconHandlePropertiesFUCHSIA(VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,zx_handle_t zirconHandle) const21770 Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const 21771 { 21772 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA && 21773 "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> requires <VK_FUCHSIA_external_memory>" ); 21774 21775 VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; 21776 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA( 21777 static_cast<VkDevice>( m_device ), 21778 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), 21779 zirconHandle, 21780 reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) ); 21781 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); 21782 21783 return memoryZirconHandleProperties; 21784 } 21785 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 21786 21787 # if defined( VK_USE_PLATFORM_FUCHSIA ) 21788 //=== VK_FUCHSIA_external_semaphore === 21789 21790 VULKAN_HPP_INLINE void importSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo) const21791 Device::importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const 21792 { 21793 VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA && 21794 "Function <vkImportSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" ); 21795 21796 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA( 21797 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) ); 21798 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); 21799 } 21800 21801 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE zx_handle_t getSemaphoreZirconHandleFUCHSIA(const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo) const21802 Device::getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const 21803 { 21804 VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA && 21805 "Function <vkGetSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" ); 21806 21807 zx_handle_t zirconHandle; 21808 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA( 21809 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) ); 21810 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); 21811 21812 return zirconHandle; 21813 } 21814 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 21815 21816 # if defined( VK_USE_PLATFORM_FUCHSIA ) 21817 //=== VK_FUCHSIA_buffer_collection === 21818 21819 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 21820 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA>::Type createBufferCollectionFUCHSIA(VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const21821 Device::createBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo, 21822 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 21823 VULKAN_HPP_RAII_CREATE_NOEXCEPT 21824 { 21825 VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection; 21826 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateBufferCollectionFUCHSIA( 21827 static_cast<VkDevice>( m_device ), 21828 reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( &createInfo ), 21829 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 21830 reinterpret_cast<VkBufferCollectionFUCHSIA *>( &collection ) ) ); 21831 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 21832 { 21833 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 21834 return VULKAN_HPP_UNEXPECTED( result ); 21835 # else 21836 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createBufferCollectionFUCHSIA" ); 21837 # endif 21838 } 21839 21840 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA( 21841 *this, *reinterpret_cast<VkBufferCollectionFUCHSIA *>( &collection ), allocator ); 21842 } 21843 setImageConstraints(const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo) const21844 VULKAN_HPP_INLINE void BufferCollectionFUCHSIA::setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const 21845 { 21846 VULKAN_HPP_ASSERT( getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA && 21847 "Function <vkSetBufferCollectionImageConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); 21848 21849 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 21850 getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast<VkDevice>( m_device ), 21851 static_cast<VkBufferCollectionFUCHSIA>( m_collection ), 21852 reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( &imageConstraintsInfo ) ) ); 21853 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setImageConstraints" ); 21854 } 21855 21856 VULKAN_HPP_INLINE void setBufferConstraints(const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo) const21857 BufferCollectionFUCHSIA::setBufferConstraints( const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const 21858 { 21859 VULKAN_HPP_ASSERT( getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA && 21860 "Function <vkSetBufferCollectionBufferConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); 21861 21862 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 21863 getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast<VkDevice>( m_device ), 21864 static_cast<VkBufferCollectionFUCHSIA>( m_collection ), 21865 reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( &bufferConstraintsInfo ) ) ); 21866 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setBufferConstraints" ); 21867 } 21868 getProperties() const21869 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA BufferCollectionFUCHSIA::getProperties() const 21870 { 21871 VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA && 21872 "Function <vkGetBufferCollectionPropertiesFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" ); 21873 21874 VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties; 21875 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 21876 getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA( static_cast<VkDevice>( m_device ), 21877 static_cast<VkBufferCollectionFUCHSIA>( m_collection ), 21878 reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( &properties ) ) ); 21879 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties" ); 21880 21881 return properties; 21882 } 21883 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 21884 21885 //=== VK_HUAWEI_subpass_shading === 21886 getSubpassShadingMaxWorkgroupSizeHUAWEI() const21887 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const 21888 { 21889 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI && 21890 "Function <vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> requires <VK_HUAWEI_subpass_shading>" ); 21891 21892 VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize; 21893 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( 21894 static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<VkExtent2D *>( &maxWorkgroupSize ) ) ); 21895 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI" ); 21896 21897 return maxWorkgroupSize; 21898 } 21899 subpassShadingHUAWEI() const21900 VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT 21901 { 21902 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSubpassShadingHUAWEI && "Function <vkCmdSubpassShadingHUAWEI> requires <VK_HUAWEI_subpass_shading>" ); 21903 21904 getDispatcher()->vkCmdSubpassShadingHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ) ); 21905 } 21906 21907 //=== VK_HUAWEI_invocation_mask === 21908 bindInvocationMaskHUAWEI(VULKAN_HPP_NAMESPACE::ImageView imageView,VULKAN_HPP_NAMESPACE::ImageLayout imageLayout) const21909 VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, 21910 VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT 21911 { 21912 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindInvocationMaskHUAWEI && "Function <vkCmdBindInvocationMaskHUAWEI> requires <VK_HUAWEI_invocation_mask>" ); 21913 21914 getDispatcher()->vkCmdBindInvocationMaskHUAWEI( 21915 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) ); 21916 } 21917 21918 //=== VK_NV_external_memory_rdma === 21919 21920 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::RemoteAddressNV getMemoryRemoteAddressNV(const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo) const21921 Device::getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const 21922 { 21923 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryRemoteAddressNV && "Function <vkGetMemoryRemoteAddressNV> requires <VK_NV_external_memory_rdma>" ); 21924 21925 VULKAN_HPP_NAMESPACE::RemoteAddressNV address; 21926 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 21927 getDispatcher()->vkGetMemoryRemoteAddressNV( static_cast<VkDevice>( m_device ), 21928 reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ), 21929 reinterpret_cast<VkRemoteAddressNV *>( &address ) ) ); 21930 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); 21931 21932 return address; 21933 } 21934 21935 //=== VK_EXT_pipeline_properties === 21936 21937 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::BaseOutStructure getPipelinePropertiesEXT(const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo) const21938 Device::getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo ) const 21939 { 21940 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelinePropertiesEXT && "Function <vkGetPipelinePropertiesEXT> requires <VK_EXT_pipeline_properties>" ); 21941 21942 VULKAN_HPP_NAMESPACE::BaseOutStructure pipelineProperties; 21943 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 21944 getDispatcher()->vkGetPipelinePropertiesEXT( static_cast<VkDevice>( m_device ), 21945 reinterpret_cast<const VkPipelineInfoEXT *>( &pipelineInfo ), 21946 reinterpret_cast<VkBaseOutStructure *>( &pipelineProperties ) ) ); 21947 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" ); 21948 21949 return pipelineProperties; 21950 } 21951 21952 //=== VK_EXT_extended_dynamic_state2 === 21953 setPatchControlPointsEXT(uint32_t patchControlPoints) const21954 VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT 21955 { 21956 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPatchControlPointsEXT && 21957 "Function <vkCmdSetPatchControlPointsEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object>" ); 21958 21959 getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), patchControlPoints ); 21960 } 21961 setRasterizerDiscardEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable) const21962 VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT 21963 { 21964 VULKAN_HPP_ASSERT( 21965 getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT && 21966 "Function <vkCmdSetRasterizerDiscardEnableEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 21967 21968 getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) ); 21969 } 21970 setDepthBiasEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable) const21971 VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT 21972 { 21973 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnableEXT && 21974 "Function <vkCmdSetDepthBiasEnableEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 21975 21976 getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) ); 21977 } 21978 setLogicOpEXT(VULKAN_HPP_NAMESPACE::LogicOp logicOp) const21979 VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT 21980 { 21981 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT && 21982 "Function <vkCmdSetLogicOpEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object>" ); 21983 21984 getDispatcher()->vkCmdSetLogicOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkLogicOp>( logicOp ) ); 21985 } 21986 setPrimitiveRestartEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable) const21987 VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT 21988 { 21989 VULKAN_HPP_ASSERT( 21990 getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT && 21991 "Function <vkCmdSetPrimitiveRestartEnableEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" ); 21992 21993 getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) ); 21994 } 21995 21996 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 21997 //=== VK_QNX_screen_surface === 21998 21999 VULKAN_HPP_NODISCARD 22000 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createScreenSurfaceQNX(VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const22001 Instance::createScreenSurfaceQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, 22002 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 22003 VULKAN_HPP_RAII_CREATE_NOEXCEPT 22004 { 22005 VULKAN_HPP_NAMESPACE::SurfaceKHR surface; 22006 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateScreenSurfaceQNX( 22007 static_cast<VkInstance>( m_instance ), 22008 reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ), 22009 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 22010 reinterpret_cast<VkSurfaceKHR *>( &surface ) ) ); 22011 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 22012 { 22013 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 22014 return VULKAN_HPP_UNEXPECTED( result ); 22015 # else 22016 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createScreenSurfaceQNX" ); 22017 # endif 22018 } 22019 22020 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator ); 22021 } 22022 22023 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX(uint32_t queueFamilyIndex,struct _screen_window & window) const22024 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT 22025 { 22026 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX && 22027 "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> requires <VK_QNX_screen_surface>" ); 22028 22029 VkBool32 result = 22030 getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &window ); 22031 22032 return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result ); 22033 } 22034 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 22035 22036 //=== VK_EXT_color_write_enable === 22037 setColorWriteEnableEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables) const22038 VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( 22039 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT 22040 { 22041 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteEnableEXT && "Function <vkCmdSetColorWriteEnableEXT> requires <VK_EXT_color_write_enable>" ); 22042 22043 getDispatcher()->vkCmdSetColorWriteEnableEXT( 22044 static_cast<VkCommandBuffer>( m_commandBuffer ), colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) ); 22045 } 22046 22047 //=== VK_KHR_ray_tracing_maintenance1 === 22048 traceRaysIndirect2KHR(VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress) const22049 VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT 22050 { 22051 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirect2KHR && "Function <vkCmdTraceRaysIndirect2KHR> requires <VK_KHR_ray_tracing_maintenance1>" ); 22052 22053 getDispatcher()->vkCmdTraceRaysIndirect2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( indirectDeviceAddress ) ); 22054 } 22055 22056 //=== VK_EXT_multi_draw === 22057 22058 VULKAN_HPP_INLINE void drawMultiEXT(VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,uint32_t instanceCount,uint32_t firstInstance) const22059 CommandBuffer::drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo, 22060 uint32_t instanceCount, 22061 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT 22062 { 22063 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiEXT && "Function <vkCmdDrawMultiEXT> requires <VK_EXT_multi_draw>" ); 22064 22065 getDispatcher()->vkCmdDrawMultiEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22066 vertexInfo.size(), 22067 reinterpret_cast<const VkMultiDrawInfoEXT *>( vertexInfo.data() ), 22068 instanceCount, 22069 firstInstance, 22070 vertexInfo.stride() ); 22071 } 22072 22073 VULKAN_HPP_INLINE void drawMultiIndexedEXT(VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,uint32_t instanceCount,uint32_t firstInstance,Optional<const int32_t> vertexOffset) const22074 CommandBuffer::drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo, 22075 uint32_t instanceCount, 22076 uint32_t firstInstance, 22077 Optional<const int32_t> vertexOffset ) const VULKAN_HPP_NOEXCEPT 22078 { 22079 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiIndexedEXT && "Function <vkCmdDrawMultiIndexedEXT> requires <VK_EXT_multi_draw>" ); 22080 22081 getDispatcher()->vkCmdDrawMultiIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22082 indexInfo.size(), 22083 reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( indexInfo.data() ), 22084 instanceCount, 22085 firstInstance, 22086 indexInfo.stride(), 22087 static_cast<const int32_t *>( vertexOffset ) ); 22088 } 22089 22090 //=== VK_EXT_opacity_micromap === 22091 22092 VULKAN_HPP_NODISCARD 22093 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT>::Type createMicromapEXT(VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const22094 Device::createMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo, 22095 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 22096 VULKAN_HPP_RAII_CREATE_NOEXCEPT 22097 { 22098 VULKAN_HPP_NAMESPACE::MicromapEXT micromap; 22099 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateMicromapEXT( 22100 static_cast<VkDevice>( m_device ), 22101 reinterpret_cast<const VkMicromapCreateInfoEXT *>( &createInfo ), 22102 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 22103 reinterpret_cast<VkMicromapEXT *>( µmap ) ) ); 22104 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 22105 { 22106 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 22107 return VULKAN_HPP_UNEXPECTED( result ); 22108 # else 22109 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createMicromapEXT" ); 22110 # endif 22111 } 22112 22113 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT( *this, *reinterpret_cast<VkMicromapEXT *>( µmap ), allocator ); 22114 } 22115 buildMicromapsEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos) const22116 VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT( 22117 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos ) const VULKAN_HPP_NOEXCEPT 22118 { 22119 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildMicromapsEXT && "Function <vkCmdBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" ); 22120 22121 getDispatcher()->vkCmdBuildMicromapsEXT( 22122 static_cast<VkCommandBuffer>( m_commandBuffer ), infos.size(), reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) ); 22123 } 22124 22125 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result buildMicromapsEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos) const22126 Device::buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 22127 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos ) const 22128 { 22129 VULKAN_HPP_ASSERT( getDispatcher()->vkBuildMicromapsEXT && "Function <vkBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" ); 22130 22131 VULKAN_HPP_NAMESPACE::Result result = 22132 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBuildMicromapsEXT( static_cast<VkDevice>( m_device ), 22133 static_cast<VkDeferredOperationKHR>( deferredOperation ), 22134 infos.size(), 22135 reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) ) ); 22136 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 22137 VULKAN_HPP_NAMESPACE_STRING "::Device::buildMicromapsEXT", 22138 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 22139 VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, 22140 VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); 22141 22142 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 22143 } 22144 copyMicromapEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info) const22145 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 22146 const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const 22147 { 22148 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapEXT && "Function <vkCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" ); 22149 22150 VULKAN_HPP_NAMESPACE::Result result = 22151 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyMicromapEXT( static_cast<VkDevice>( m_device ), 22152 static_cast<VkDeferredOperationKHR>( deferredOperation ), 22153 reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) ) ); 22154 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 22155 VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapEXT", 22156 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 22157 VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, 22158 VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); 22159 22160 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 22161 } 22162 22163 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info) const22164 Device::copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 22165 const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const 22166 { 22167 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapToMemoryEXT && "Function <vkCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" ); 22168 22169 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 22170 getDispatcher()->vkCopyMicromapToMemoryEXT( static_cast<VkDevice>( m_device ), 22171 static_cast<VkDeferredOperationKHR>( deferredOperation ), 22172 reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) ) ); 22173 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 22174 VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapToMemoryEXT", 22175 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 22176 VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, 22177 VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); 22178 22179 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 22180 } 22181 22182 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT(VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info) const22183 Device::copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, 22184 const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const 22185 { 22186 VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToMicromapEXT && "Function <vkCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" ); 22187 22188 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 22189 getDispatcher()->vkCopyMemoryToMicromapEXT( static_cast<VkDevice>( m_device ), 22190 static_cast<VkDeferredOperationKHR>( deferredOperation ), 22191 reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) ) ); 22192 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, 22193 VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToMicromapEXT", 22194 { VULKAN_HPP_NAMESPACE::Result::eSuccess, 22195 VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR, 22196 VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } ); 22197 22198 return static_cast<VULKAN_HPP_NAMESPACE::Result>( result ); 22199 } 22200 22201 template <typename DataType> 22202 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> writeMicromapsPropertiesEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,VULKAN_HPP_NAMESPACE::QueryType queryType,size_t dataSize,size_t stride) const22203 Device::writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, 22204 VULKAN_HPP_NAMESPACE::QueryType queryType, 22205 size_t dataSize, 22206 size_t stride ) const 22207 { 22208 VULKAN_HPP_ASSERT( getDispatcher()->vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" ); 22209 22210 VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); 22211 std::vector<DataType> data( dataSize / sizeof( DataType ) ); 22212 VULKAN_HPP_NAMESPACE::Result result = 22213 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast<VkDevice>( m_device ), 22214 micromaps.size(), 22215 reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ), 22216 static_cast<VkQueryType>( queryType ), 22217 data.size() * sizeof( DataType ), 22218 reinterpret_cast<void *>( data.data() ), 22219 stride ) ); 22220 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" ); 22221 22222 return data; 22223 } 22224 22225 template <typename DataType> 22226 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType writeMicromapsPropertyEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,VULKAN_HPP_NAMESPACE::QueryType queryType,size_t stride) const22227 Device::writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, 22228 VULKAN_HPP_NAMESPACE::QueryType queryType, 22229 size_t stride ) const 22230 { 22231 VULKAN_HPP_ASSERT( getDispatcher()->vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" ); 22232 22233 DataType data; 22234 VULKAN_HPP_NAMESPACE::Result result = 22235 static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast<VkDevice>( m_device ), 22236 micromaps.size(), 22237 reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ), 22238 static_cast<VkQueryType>( queryType ), 22239 sizeof( DataType ), 22240 reinterpret_cast<void *>( &data ), 22241 stride ) ); 22242 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" ); 22243 22244 return data; 22245 } 22246 copyMicromapEXT(const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info) const22247 VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT 22248 { 22249 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapEXT && "Function <vkCmdCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" ); 22250 22251 getDispatcher()->vkCmdCopyMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) ); 22252 } 22253 copyMicromapToMemoryEXT(const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info) const22254 VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT 22255 { 22256 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapToMemoryEXT && "Function <vkCmdCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" ); 22257 22258 getDispatcher()->vkCmdCopyMicromapToMemoryEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22259 reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) ); 22260 } 22261 copyMemoryToMicromapEXT(const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info) const22262 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT 22263 { 22264 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToMicromapEXT && "Function <vkCmdCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" ); 22265 22266 getDispatcher()->vkCmdCopyMemoryToMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22267 reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) ); 22268 } 22269 22270 VULKAN_HPP_INLINE void writeMicromapsPropertiesEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,VULKAN_HPP_NAMESPACE::QueryType queryType,VULKAN_HPP_NAMESPACE::QueryPool queryPool,uint32_t firstQuery) const22271 CommandBuffer::writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps, 22272 VULKAN_HPP_NAMESPACE::QueryType queryType, 22273 VULKAN_HPP_NAMESPACE::QueryPool queryPool, 22274 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT 22275 { 22276 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteMicromapsPropertiesEXT && 22277 "Function <vkCmdWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" ); 22278 22279 getDispatcher()->vkCmdWriteMicromapsPropertiesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22280 micromaps.size(), 22281 reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ), 22282 static_cast<VkQueryType>( queryType ), 22283 static_cast<VkQueryPool>( queryPool ), 22284 firstQuery ); 22285 } 22286 22287 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT(const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo) const22288 Device::getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT 22289 { 22290 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMicromapCompatibilityEXT && 22291 "Function <vkGetDeviceMicromapCompatibilityEXT> requires <VK_EXT_opacity_micromap>" ); 22292 22293 VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR compatibility; 22294 getDispatcher()->vkGetDeviceMicromapCompatibilityEXT( static_cast<VkDevice>( m_device ), 22295 reinterpret_cast<const VkMicromapVersionInfoEXT *>( &versionInfo ), 22296 reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) ); 22297 22298 return compatibility; 22299 } 22300 22301 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT getMicromapBuildSizesEXT(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo) const22302 Device::getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType, 22303 const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo ) const VULKAN_HPP_NOEXCEPT 22304 { 22305 VULKAN_HPP_ASSERT( getDispatcher()->vkGetMicromapBuildSizesEXT && "Function <vkGetMicromapBuildSizesEXT> requires <VK_EXT_opacity_micromap>" ); 22306 22307 VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT sizeInfo; 22308 getDispatcher()->vkGetMicromapBuildSizesEXT( static_cast<VkDevice>( m_device ), 22309 static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ), 22310 reinterpret_cast<const VkMicromapBuildInfoEXT *>( &buildInfo ), 22311 reinterpret_cast<VkMicromapBuildSizesInfoEXT *>( &sizeInfo ) ); 22312 22313 return sizeInfo; 22314 } 22315 22316 //=== VK_HUAWEI_cluster_culling_shader === 22317 drawClusterHUAWEI(uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const22318 VULKAN_HPP_INLINE void CommandBuffer::drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 22319 { 22320 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawClusterHUAWEI && "Function <vkCmdDrawClusterHUAWEI> requires <VK_HUAWEI_cluster_culling_shader>" ); 22321 22322 getDispatcher()->vkCmdDrawClusterHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); 22323 } 22324 drawClusterIndirectHUAWEI(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset) const22325 VULKAN_HPP_INLINE void CommandBuffer::drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, 22326 VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT 22327 { 22328 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawClusterIndirectHUAWEI && 22329 "Function <vkCmdDrawClusterIndirectHUAWEI> requires <VK_HUAWEI_cluster_culling_shader>" ); 22330 22331 getDispatcher()->vkCmdDrawClusterIndirectHUAWEI( 22332 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) ); 22333 } 22334 22335 //=== VK_EXT_pageable_device_local_memory === 22336 setPriorityEXT(float priority) const22337 VULKAN_HPP_INLINE void DeviceMemory::setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT 22338 { 22339 VULKAN_HPP_ASSERT( getDispatcher()->vkSetDeviceMemoryPriorityEXT && 22340 "Function <vkSetDeviceMemoryPriorityEXT> requires <VK_EXT_pageable_device_local_memory>" ); 22341 22342 getDispatcher()->vkSetDeviceMemoryPriorityEXT( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), priority ); 22343 } 22344 22345 //=== VK_KHR_maintenance4 === 22346 22347 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info) const22348 Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT 22349 { 22350 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && 22351 "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 22352 22353 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 22354 getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast<VkDevice>( m_device ), 22355 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), 22356 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 22357 22358 return memoryRequirements; 22359 } 22360 22361 template <typename X, typename Y, typename... Z> 22362 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getBufferMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info) const22363 Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT 22364 { 22365 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && 22366 "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 22367 22368 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 22369 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 22370 getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast<VkDevice>( m_device ), 22371 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ), 22372 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 22373 22374 return structureChain; 22375 } 22376 22377 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info) const22378 Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT 22379 { 22380 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && 22381 "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 22382 22383 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 22384 getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast<VkDevice>( m_device ), 22385 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), 22386 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 22387 22388 return memoryRequirements; 22389 } 22390 22391 template <typename X, typename Y, typename... Z> 22392 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info) const22393 Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT 22394 { 22395 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && 22396 "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 22397 22398 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 22399 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 22400 getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast<VkDevice>( m_device ), 22401 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), 22402 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 22403 22404 return structureChain; 22405 } 22406 22407 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> getImageSparseMemoryRequirementsKHR(const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info) const22408 Device::getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const 22409 { 22410 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR && 22411 "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" ); 22412 22413 std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements; 22414 uint32_t sparseMemoryRequirementCount; 22415 getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( 22416 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr ); 22417 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 22418 getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast<VkDevice>( m_device ), 22419 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), 22420 &sparseMemoryRequirementCount, 22421 reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) ); 22422 22423 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); 22424 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) 22425 { 22426 sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); 22427 } 22428 return sparseMemoryRequirements; 22429 } 22430 22431 //=== VK_VALVE_descriptor_set_host_mapping === 22432 getDescriptorSetLayoutHostMappingInfoVALVE(const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference) const22433 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE Device::getDescriptorSetLayoutHostMappingInfoVALVE( 22434 const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference ) const VULKAN_HPP_NOEXCEPT 22435 { 22436 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE && 22437 "Function <vkGetDescriptorSetLayoutHostMappingInfoVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" ); 22438 22439 VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE hostMapping; 22440 getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE( static_cast<VkDevice>( m_device ), 22441 reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>( &bindingReference ), 22442 reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( &hostMapping ) ); 22443 22444 return hostMapping; 22445 } 22446 getHostMappingVALVE() const22447 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * DescriptorSet::getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT 22448 { 22449 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetHostMappingVALVE && 22450 "Function <vkGetDescriptorSetHostMappingVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" ); 22451 22452 void * pData; 22453 getDispatcher()->vkGetDescriptorSetHostMappingVALVE( static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSet>( m_descriptorSet ), &pData ); 22454 22455 return pData; 22456 } 22457 22458 //=== VK_NV_copy_memory_indirect === 22459 copyMemoryIndirectNV(VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,uint32_t copyCount,uint32_t stride) const22460 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, 22461 uint32_t copyCount, 22462 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 22463 { 22464 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryIndirectNV && "Function <vkCmdCopyMemoryIndirectNV> requires <VK_NV_copy_memory_indirect>" ); 22465 22466 getDispatcher()->vkCmdCopyMemoryIndirectNV( 22467 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( copyBufferAddress ), copyCount, stride ); 22468 } 22469 copyMemoryToImageIndirectNV(VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,uint32_t stride,VULKAN_HPP_NAMESPACE::Image dstImage,VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources) const22470 VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV( 22471 VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, 22472 uint32_t stride, 22473 VULKAN_HPP_NAMESPACE::Image dstImage, 22474 VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout, 22475 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources ) const VULKAN_HPP_NOEXCEPT 22476 { 22477 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToImageIndirectNV && 22478 "Function <vkCmdCopyMemoryToImageIndirectNV> requires <VK_NV_copy_memory_indirect>" ); 22479 22480 getDispatcher()->vkCmdCopyMemoryToImageIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 22481 static_cast<VkDeviceAddress>( copyBufferAddress ), 22482 imageSubresources.size(), 22483 stride, 22484 static_cast<VkImage>( dstImage ), 22485 static_cast<VkImageLayout>( dstImageLayout ), 22486 reinterpret_cast<const VkImageSubresourceLayers *>( imageSubresources.data() ) ); 22487 } 22488 22489 //=== VK_NV_memory_decompression === 22490 decompressMemoryNV(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions) const22491 VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV( 22492 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT 22493 { 22494 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryNV && "Function <vkCmdDecompressMemoryNV> requires <VK_NV_memory_decompression>" ); 22495 22496 getDispatcher()->vkCmdDecompressMemoryNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 22497 decompressMemoryRegions.size(), 22498 reinterpret_cast<const VkDecompressMemoryRegionNV *>( decompressMemoryRegions.data() ) ); 22499 } 22500 decompressMemoryIndirectCountNV(VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,uint32_t stride) const22501 VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress, 22502 VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress, 22503 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 22504 { 22505 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryIndirectCountNV && 22506 "Function <vkCmdDecompressMemoryIndirectCountNV> requires <VK_NV_memory_decompression>" ); 22507 22508 getDispatcher()->vkCmdDecompressMemoryIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 22509 static_cast<VkDeviceAddress>( indirectCommandsAddress ), 22510 static_cast<VkDeviceAddress>( indirectCommandsCountAddress ), 22511 stride ); 22512 } 22513 22514 //=== VK_NV_device_generated_commands_compute === 22515 22516 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2 getPipelineIndirectMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo) const22517 Device::getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 22518 { 22519 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV && 22520 "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" ); 22521 22522 VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements; 22523 getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV( static_cast<VkDevice>( m_device ), 22524 reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), 22525 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 22526 22527 return memoryRequirements; 22528 } 22529 22530 template <typename X, typename Y, typename... Z> 22531 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getPipelineIndirectMemoryRequirementsNV(const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo) const22532 Device::getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 22533 { 22534 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV && 22535 "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" ); 22536 22537 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 22538 VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>(); 22539 getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV( static_cast<VkDevice>( m_device ), 22540 reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ), 22541 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) ); 22542 22543 return structureChain; 22544 } 22545 updatePipelineIndirectBufferNV(VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,VULKAN_HPP_NAMESPACE::Pipeline pipeline) const22546 VULKAN_HPP_INLINE void CommandBuffer::updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, 22547 VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT 22548 { 22549 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdUpdatePipelineIndirectBufferNV && 22550 "Function <vkCmdUpdatePipelineIndirectBufferNV> requires <VK_NV_device_generated_commands_compute>" ); 22551 22552 getDispatcher()->vkCmdUpdatePipelineIndirectBufferNV( 22553 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) ); 22554 } 22555 22556 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceAddress getPipelineIndirectAddressNV(const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info) const22557 Device::getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info ) const VULKAN_HPP_NOEXCEPT 22558 { 22559 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineIndirectDeviceAddressNV && 22560 "Function <vkGetPipelineIndirectDeviceAddressNV> requires <VK_NV_device_generated_commands_compute>" ); 22561 22562 VkDeviceAddress result = getDispatcher()->vkGetPipelineIndirectDeviceAddressNV( 22563 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV *>( &info ) ); 22564 22565 return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result ); 22566 } 22567 22568 //=== VK_EXT_extended_dynamic_state3 === 22569 setDepthClampEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable) const22570 VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT 22571 { 22572 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampEnableEXT && 22573 "Function <vkCmdSetDepthClampEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22574 22575 getDispatcher()->vkCmdSetDepthClampEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClampEnable ) ); 22576 } 22577 setPolygonModeEXT(VULKAN_HPP_NAMESPACE::PolygonMode polygonMode) const22578 VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT 22579 { 22580 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPolygonModeEXT && 22581 "Function <vkCmdSetPolygonModeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22582 22583 getDispatcher()->vkCmdSetPolygonModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPolygonMode>( polygonMode ) ); 22584 } 22585 setRasterizationSamplesEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples) const22586 VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT 22587 { 22588 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizationSamplesEXT && 22589 "Function <vkCmdSetRasterizationSamplesEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22590 22591 getDispatcher()->vkCmdSetRasterizationSamplesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22592 static_cast<VkSampleCountFlagBits>( rasterizationSamples ) ); 22593 } 22594 setSampleMaskEXT(VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask) const22595 VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, 22596 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask ) const 22597 { 22598 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleMaskEXT && 22599 "Function <vkCmdSetSampleMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22600 # ifdef VULKAN_HPP_NO_EXCEPTIONS 22601 VULKAN_HPP_ASSERT( sampleMask.size() == ( static_cast<uint32_t>( samples ) + 31 ) / 32 ); 22602 # else 22603 if ( sampleMask.size() != ( static_cast<uint32_t>( samples ) + 31 ) / 32 ) 22604 { 22605 throw LogicError( VULKAN_HPP_NAMESPACE_STRING 22606 "::CommandBuffer::setSampleMaskEXT: sampleMask.size() != ( static_cast<uint32_t>( samples ) + 31 ) / 32" ); 22607 } 22608 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 22609 22610 getDispatcher()->vkCmdSetSampleMaskEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22611 static_cast<VkSampleCountFlagBits>( samples ), 22612 reinterpret_cast<const VkSampleMask *>( sampleMask.data() ) ); 22613 } 22614 setAlphaToCoverageEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable) const22615 VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT 22616 { 22617 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT && 22618 "Function <vkCmdSetAlphaToCoverageEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22619 22620 getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToCoverageEnable ) ); 22621 } 22622 setAlphaToOneEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable) const22623 VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT 22624 { 22625 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToOneEnableEXT && 22626 "Function <vkCmdSetAlphaToOneEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22627 22628 getDispatcher()->vkCmdSetAlphaToOneEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToOneEnable ) ); 22629 } 22630 setLogicOpEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable) const22631 VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT 22632 { 22633 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEnableEXT && 22634 "Function <vkCmdSetLogicOpEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22635 22636 getDispatcher()->vkCmdSetLogicOpEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( logicOpEnable ) ); 22637 } 22638 setColorBlendEnableEXT(uint32_t firstAttachment,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables) const22639 VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( 22640 uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT 22641 { 22642 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEnableEXT && 22643 "Function <vkCmdSetColorBlendEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22644 22645 getDispatcher()->vkCmdSetColorBlendEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22646 firstAttachment, 22647 colorBlendEnables.size(), 22648 reinterpret_cast<const VkBool32 *>( colorBlendEnables.data() ) ); 22649 } 22650 setColorBlendEquationEXT(uint32_t firstAttachment,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations) const22651 VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT( 22652 uint32_t firstAttachment, 22653 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations ) const VULKAN_HPP_NOEXCEPT 22654 { 22655 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEquationEXT && 22656 "Function <vkCmdSetColorBlendEquationEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22657 22658 getDispatcher()->vkCmdSetColorBlendEquationEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22659 firstAttachment, 22660 colorBlendEquations.size(), 22661 reinterpret_cast<const VkColorBlendEquationEXT *>( colorBlendEquations.data() ) ); 22662 } 22663 setColorWriteMaskEXT(uint32_t firstAttachment,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks) const22664 VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( 22665 uint32_t firstAttachment, 22666 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks ) const VULKAN_HPP_NOEXCEPT 22667 { 22668 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteMaskEXT && 22669 "Function <vkCmdSetColorWriteMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22670 22671 getDispatcher()->vkCmdSetColorWriteMaskEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22672 firstAttachment, 22673 colorWriteMasks.size(), 22674 reinterpret_cast<const VkColorComponentFlags *>( colorWriteMasks.data() ) ); 22675 } 22676 22677 VULKAN_HPP_INLINE void setTessellationDomainOriginEXT(VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin) const22678 CommandBuffer::setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT 22679 { 22680 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetTessellationDomainOriginEXT && 22681 "Function <vkCmdSetTessellationDomainOriginEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22682 22683 getDispatcher()->vkCmdSetTessellationDomainOriginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22684 static_cast<VkTessellationDomainOrigin>( domainOrigin ) ); 22685 } 22686 setRasterizationStreamEXT(uint32_t rasterizationStream) const22687 VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT 22688 { 22689 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizationStreamEXT && 22690 "Function <vkCmdSetRasterizationStreamEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22691 22692 getDispatcher()->vkCmdSetRasterizationStreamEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), rasterizationStream ); 22693 } 22694 setConservativeRasterizationModeEXT(VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode) const22695 VULKAN_HPP_INLINE void CommandBuffer::setConservativeRasterizationModeEXT( 22696 VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT 22697 { 22698 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetConservativeRasterizationModeEXT && 22699 "Function <vkCmdSetConservativeRasterizationModeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22700 22701 getDispatcher()->vkCmdSetConservativeRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22702 static_cast<VkConservativeRasterizationModeEXT>( conservativeRasterizationMode ) ); 22703 } 22704 setExtraPrimitiveOverestimationSizeEXT(float extraPrimitiveOverestimationSize) const22705 VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT 22706 { 22707 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT && 22708 "Function <vkCmdSetExtraPrimitiveOverestimationSizeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22709 22710 getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), extraPrimitiveOverestimationSize ); 22711 } 22712 setDepthClipEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable) const22713 VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT 22714 { 22715 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipEnableEXT && 22716 "Function <vkCmdSetDepthClipEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22717 22718 getDispatcher()->vkCmdSetDepthClipEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClipEnable ) ); 22719 } 22720 setSampleLocationsEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable) const22721 VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT 22722 { 22723 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEnableEXT && 22724 "Function <vkCmdSetSampleLocationsEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22725 22726 getDispatcher()->vkCmdSetSampleLocationsEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( sampleLocationsEnable ) ); 22727 } 22728 setColorBlendAdvancedEXT(uint32_t firstAttachment,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced) const22729 VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT( 22730 uint32_t firstAttachment, 22731 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT 22732 { 22733 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendAdvancedEXT && 22734 "Function <vkCmdSetColorBlendAdvancedEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22735 22736 getDispatcher()->vkCmdSetColorBlendAdvancedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22737 firstAttachment, 22738 colorBlendAdvanced.size(), 22739 reinterpret_cast<const VkColorBlendAdvancedEXT *>( colorBlendAdvanced.data() ) ); 22740 } 22741 22742 VULKAN_HPP_INLINE void setProvokingVertexModeEXT(VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode) const22743 CommandBuffer::setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT 22744 { 22745 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetProvokingVertexModeEXT && 22746 "Function <vkCmdSetProvokingVertexModeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22747 22748 getDispatcher()->vkCmdSetProvokingVertexModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22749 static_cast<VkProvokingVertexModeEXT>( provokingVertexMode ) ); 22750 } 22751 22752 VULKAN_HPP_INLINE void setLineRasterizationModeEXT(VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode) const22753 CommandBuffer::setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT 22754 { 22755 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineRasterizationModeEXT && 22756 "Function <vkCmdSetLineRasterizationModeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22757 22758 getDispatcher()->vkCmdSetLineRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 22759 static_cast<VkLineRasterizationModeEXT>( lineRasterizationMode ) ); 22760 } 22761 setLineStippleEnableEXT(VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable) const22762 VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT 22763 { 22764 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEnableEXT && 22765 "Function <vkCmdSetLineStippleEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22766 22767 getDispatcher()->vkCmdSetLineStippleEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stippledLineEnable ) ); 22768 } 22769 setDepthClipNegativeOneToOneEXT(VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne) const22770 VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT 22771 { 22772 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT && 22773 "Function <vkCmdSetDepthClipNegativeOneToOneEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22774 22775 getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( negativeOneToOne ) ); 22776 } 22777 setViewportWScalingEnableNV(VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable) const22778 VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT 22779 { 22780 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWScalingEnableNV && 22781 "Function <vkCmdSetViewportWScalingEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22782 22783 getDispatcher()->vkCmdSetViewportWScalingEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( viewportWScalingEnable ) ); 22784 } 22785 setViewportSwizzleNV(uint32_t firstViewport,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles) const22786 VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( 22787 uint32_t firstViewport, 22788 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles ) const VULKAN_HPP_NOEXCEPT 22789 { 22790 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportSwizzleNV && 22791 "Function <vkCmdSetViewportSwizzleNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22792 22793 getDispatcher()->vkCmdSetViewportSwizzleNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 22794 firstViewport, 22795 viewportSwizzles.size(), 22796 reinterpret_cast<const VkViewportSwizzleNV *>( viewportSwizzles.data() ) ); 22797 } 22798 setCoverageToColorEnableNV(VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable) const22799 VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT 22800 { 22801 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageToColorEnableNV && 22802 "Function <vkCmdSetCoverageToColorEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22803 22804 getDispatcher()->vkCmdSetCoverageToColorEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( coverageToColorEnable ) ); 22805 } 22806 setCoverageToColorLocationNV(uint32_t coverageToColorLocation) const22807 VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT 22808 { 22809 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageToColorLocationNV && 22810 "Function <vkCmdSetCoverageToColorLocationNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22811 22812 getDispatcher()->vkCmdSetCoverageToColorLocationNV( static_cast<VkCommandBuffer>( m_commandBuffer ), coverageToColorLocation ); 22813 } 22814 22815 VULKAN_HPP_INLINE void setCoverageModulationModeNV(VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode) const22816 CommandBuffer::setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT 22817 { 22818 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationModeNV && 22819 "Function <vkCmdSetCoverageModulationModeNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22820 22821 getDispatcher()->vkCmdSetCoverageModulationModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 22822 static_cast<VkCoverageModulationModeNV>( coverageModulationMode ) ); 22823 } 22824 22825 VULKAN_HPP_INLINE void setCoverageModulationTableEnableNV(VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable) const22826 CommandBuffer::setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT 22827 { 22828 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationTableEnableNV && 22829 "Function <vkCmdSetCoverageModulationTableEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22830 22831 getDispatcher()->vkCmdSetCoverageModulationTableEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 22832 static_cast<VkBool32>( coverageModulationTableEnable ) ); 22833 } 22834 22835 VULKAN_HPP_INLINE void setCoverageModulationTableNV(VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable) const22836 CommandBuffer::setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT 22837 { 22838 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationTableNV && 22839 "Function <vkCmdSetCoverageModulationTableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22840 22841 getDispatcher()->vkCmdSetCoverageModulationTableNV( 22842 static_cast<VkCommandBuffer>( m_commandBuffer ), coverageModulationTable.size(), coverageModulationTable.data() ); 22843 } 22844 setShadingRateImageEnableNV(VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable) const22845 VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT 22846 { 22847 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetShadingRateImageEnableNV && 22848 "Function <vkCmdSetShadingRateImageEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22849 22850 getDispatcher()->vkCmdSetShadingRateImageEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( shadingRateImageEnable ) ); 22851 } 22852 22853 VULKAN_HPP_INLINE void setRepresentativeFragmentTestEnableNV(VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable) const22854 CommandBuffer::setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT 22855 { 22856 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV && 22857 "Function <vkCmdSetRepresentativeFragmentTestEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22858 22859 getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 22860 static_cast<VkBool32>( representativeFragmentTestEnable ) ); 22861 } 22862 22863 VULKAN_HPP_INLINE void setCoverageReductionModeNV(VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode) const22864 CommandBuffer::setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT 22865 { 22866 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageReductionModeNV && 22867 "Function <vkCmdSetCoverageReductionModeNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" ); 22868 22869 getDispatcher()->vkCmdSetCoverageReductionModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 22870 static_cast<VkCoverageReductionModeNV>( coverageReductionMode ) ); 22871 } 22872 22873 //=== VK_EXT_shader_module_identifier === 22874 getIdentifierEXT() const22875 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT ShaderModule::getIdentifierEXT() const VULKAN_HPP_NOEXCEPT 22876 { 22877 VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderModuleIdentifierEXT && 22878 "Function <vkGetShaderModuleIdentifierEXT> requires <VK_EXT_shader_module_identifier>" ); 22879 22880 VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT identifier; 22881 getDispatcher()->vkGetShaderModuleIdentifierEXT( 22882 static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( m_shaderModule ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) ); 22883 22884 return identifier; 22885 } 22886 22887 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT(const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo) const22888 Device::getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT 22889 { 22890 VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderModuleCreateInfoIdentifierEXT && 22891 "Function <vkGetShaderModuleCreateInfoIdentifierEXT> requires <VK_EXT_shader_module_identifier>" ); 22892 22893 VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT identifier; 22894 getDispatcher()->vkGetShaderModuleCreateInfoIdentifierEXT( static_cast<VkDevice>( m_device ), 22895 reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ), 22896 reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) ); 22897 22898 return identifier; 22899 } 22900 22901 //=== VK_NV_optical_flow === 22902 22903 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> getOpticalFlowImageFormatsNV(const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo) const22904 PhysicalDevice::getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const 22905 { 22906 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV && 22907 "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> requires <VK_NV_optical_flow>" ); 22908 22909 std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> imageFormatProperties; 22910 uint32_t formatCount; 22911 VULKAN_HPP_NAMESPACE::Result result; 22912 do 22913 { 22914 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV( 22915 static_cast<VkPhysicalDevice>( m_physicalDevice ), 22916 reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ), 22917 &formatCount, 22918 nullptr ) ); 22919 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && formatCount ) 22920 { 22921 imageFormatProperties.resize( formatCount ); 22922 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV( 22923 static_cast<VkPhysicalDevice>( m_physicalDevice ), 22924 reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ), 22925 &formatCount, 22926 reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( imageFormatProperties.data() ) ) ); 22927 } 22928 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 22929 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" ); 22930 VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); 22931 if ( formatCount < imageFormatProperties.size() ) 22932 { 22933 imageFormatProperties.resize( formatCount ); 22934 } 22935 return imageFormatProperties; 22936 } 22937 22938 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 22939 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV>::Type createOpticalFlowSessionNV(VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const22940 Device::createOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo, 22941 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 22942 VULKAN_HPP_RAII_CREATE_NOEXCEPT 22943 { 22944 VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session; 22945 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateOpticalFlowSessionNV( 22946 static_cast<VkDevice>( m_device ), 22947 reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( &createInfo ), 22948 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 22949 reinterpret_cast<VkOpticalFlowSessionNV *>( &session ) ) ); 22950 if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) 22951 { 22952 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 22953 return VULKAN_HPP_UNEXPECTED( result ); 22954 # else 22955 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createOpticalFlowSessionNV" ); 22956 # endif 22957 } 22958 22959 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV( *this, *reinterpret_cast<VkOpticalFlowSessionNV *>( &session ), allocator ); 22960 } 22961 bindImage(VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,VULKAN_HPP_NAMESPACE::ImageView view,VULKAN_HPP_NAMESPACE::ImageLayout layout) const22962 VULKAN_HPP_INLINE void OpticalFlowSessionNV::bindImage( VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint, 22963 VULKAN_HPP_NAMESPACE::ImageView view, 22964 VULKAN_HPP_NAMESPACE::ImageLayout layout ) const 22965 { 22966 VULKAN_HPP_ASSERT( getDispatcher()->vkBindOpticalFlowSessionImageNV && "Function <vkBindOpticalFlowSessionImageNV> requires <VK_NV_optical_flow>" ); 22967 22968 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 22969 getDispatcher()->vkBindOpticalFlowSessionImageNV( static_cast<VkDevice>( m_device ), 22970 static_cast<VkOpticalFlowSessionNV>( m_session ), 22971 static_cast<VkOpticalFlowSessionBindingPointNV>( bindingPoint ), 22972 static_cast<VkImageView>( view ), 22973 static_cast<VkImageLayout>( layout ) ) ); 22974 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::OpticalFlowSessionNV::bindImage" ); 22975 } 22976 opticalFlowExecuteNV(VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo) const22977 VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, 22978 const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT 22979 { 22980 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdOpticalFlowExecuteNV && "Function <vkCmdOpticalFlowExecuteNV> requires <VK_NV_optical_flow>" ); 22981 22982 getDispatcher()->vkCmdOpticalFlowExecuteNV( static_cast<VkCommandBuffer>( m_commandBuffer ), 22983 static_cast<VkOpticalFlowSessionNV>( session ), 22984 reinterpret_cast<const VkOpticalFlowExecuteInfoNV *>( &executeInfo ) ); 22985 } 22986 22987 //=== VK_KHR_maintenance5 === 22988 bindIndexBuffer2KHR(VULKAN_HPP_NAMESPACE::Buffer buffer,VULKAN_HPP_NAMESPACE::DeviceSize offset,VULKAN_HPP_NAMESPACE::DeviceSize size,VULKAN_HPP_NAMESPACE::IndexType indexType) const22989 VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer, 22990 VULKAN_HPP_NAMESPACE::DeviceSize offset, 22991 VULKAN_HPP_NAMESPACE::DeviceSize size, 22992 VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT 22993 { 22994 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer2KHR && 22995 "Function <vkCmdBindIndexBuffer2KHR> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 22996 22997 getDispatcher()->vkCmdBindIndexBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 22998 static_cast<VkBuffer>( buffer ), 22999 static_cast<VkDeviceSize>( offset ), 23000 static_cast<VkDeviceSize>( size ), 23001 static_cast<VkIndexType>( indexType ) ); 23002 } 23003 23004 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D getRenderingAreaGranularityKHR(const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo) const23005 Device::getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT 23006 { 23007 VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderingAreaGranularityKHR && 23008 "Function <vkGetRenderingAreaGranularityKHR> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 23009 23010 VULKAN_HPP_NAMESPACE::Extent2D granularity; 23011 getDispatcher()->vkGetRenderingAreaGranularityKHR( static_cast<VkDevice>( m_device ), 23012 reinterpret_cast<const VkRenderingAreaInfo *>( &renderingAreaInfo ), 23013 reinterpret_cast<VkExtent2D *>( &granularity ) ); 23014 23015 return granularity; 23016 } 23017 23018 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2 getImageSubresourceLayoutKHR(const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info) const23019 Device::getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT 23020 { 23021 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR && 23022 "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 23023 23024 VULKAN_HPP_NAMESPACE::SubresourceLayout2 layout; 23025 getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR( static_cast<VkDevice>( m_device ), 23026 reinterpret_cast<const VkDeviceImageSubresourceInfo *>( &info ), 23027 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 23028 23029 return layout; 23030 } 23031 23032 template <typename X, typename Y, typename... Z> 23033 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getImageSubresourceLayoutKHR(const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info) const23034 Device::getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT 23035 { 23036 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR && 23037 "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 23038 23039 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 23040 VULKAN_HPP_NAMESPACE::SubresourceLayout2 & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2>(); 23041 getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR( static_cast<VkDevice>( m_device ), 23042 reinterpret_cast<const VkDeviceImageSubresourceInfo *>( &info ), 23043 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 23044 23045 return structureChain; 23046 } 23047 23048 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2 getSubresourceLayout2KHR(const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource) const23049 Image::getSubresourceLayout2KHR( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT 23050 { 23051 VULKAN_HPP_ASSERT( 23052 getDispatcher()->vkGetImageSubresourceLayout2KHR && 23053 "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 23054 23055 VULKAN_HPP_NAMESPACE::SubresourceLayout2 layout; 23056 getDispatcher()->vkGetImageSubresourceLayout2KHR( static_cast<VkDevice>( m_device ), 23057 static_cast<VkImage>( m_image ), 23058 reinterpret_cast<const VkImageSubresource2 *>( &subresource ), 23059 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 23060 23061 return layout; 23062 } 23063 23064 template <typename X, typename Y, typename... Z> 23065 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getSubresourceLayout2KHR(const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource) const23066 Image::getSubresourceLayout2KHR( const VULKAN_HPP_NAMESPACE::ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT 23067 { 23068 VULKAN_HPP_ASSERT( 23069 getDispatcher()->vkGetImageSubresourceLayout2KHR && 23070 "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5> or <VK_VERSION_1_4>" ); 23071 23072 VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain; 23073 VULKAN_HPP_NAMESPACE::SubresourceLayout2 & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2>(); 23074 getDispatcher()->vkGetImageSubresourceLayout2KHR( static_cast<VkDevice>( m_device ), 23075 static_cast<VkImage>( m_image ), 23076 reinterpret_cast<const VkImageSubresource2 *>( &subresource ), 23077 reinterpret_cast<VkSubresourceLayout2 *>( &layout ) ); 23078 23079 return structureChain; 23080 } 23081 23082 //=== VK_AMD_anti_lag === 23083 antiLagUpdateAMD(const VULKAN_HPP_NAMESPACE::AntiLagDataAMD & data) const23084 VULKAN_HPP_INLINE void Device::antiLagUpdateAMD( const VULKAN_HPP_NAMESPACE::AntiLagDataAMD & data ) const VULKAN_HPP_NOEXCEPT 23085 { 23086 VULKAN_HPP_ASSERT( getDispatcher()->vkAntiLagUpdateAMD && "Function <vkAntiLagUpdateAMD> requires <VK_AMD_anti_lag>" ); 23087 23088 getDispatcher()->vkAntiLagUpdateAMD( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAntiLagDataAMD *>( &data ) ); 23089 } 23090 23091 //=== VK_EXT_shader_object === 23092 23093 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 23094 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT>>::Type createShadersEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const23095 Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos, 23096 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 23097 { 23098 std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT> shaders( createInfos.size() ); 23099 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateShadersEXT( 23100 static_cast<VkDevice>( m_device ), 23101 createInfos.size(), 23102 reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ), 23103 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 23104 reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) ); 23105 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT ) ) 23106 { 23107 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 23108 return VULKAN_HPP_UNEXPECTED( result ); 23109 # else 23110 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createShadersEXT" ); 23111 # endif 23112 } 23113 23114 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT> shadersRAII; 23115 shadersRAII.reserve( shaders.size() ); 23116 for ( auto & shader : shaders ) 23117 { 23118 shadersRAII.emplace_back( *this, *reinterpret_cast<VkShaderEXT *>( &shader ), allocator, result ); 23119 } 23120 return shadersRAII; 23121 } 23122 23123 VULKAN_HPP_NODISCARD 23124 VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT>::Type createShaderEXT(VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const23125 Device::createShaderEXT( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo, 23126 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT 23127 { 23128 VULKAN_HPP_NAMESPACE::ShaderEXT shader; 23129 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateShadersEXT( 23130 static_cast<VkDevice>( m_device ), 23131 1, 23132 reinterpret_cast<const VkShaderCreateInfoEXT *>( &createInfo ), 23133 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 23134 reinterpret_cast<VkShaderEXT *>( &shader ) ) ); 23135 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncompatibleShaderBinaryEXT ) ) 23136 { 23137 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 23138 return VULKAN_HPP_UNEXPECTED( result ); 23139 # else 23140 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createShaderEXT" ); 23141 # endif 23142 } 23143 23144 return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT( *this, *reinterpret_cast<VkShaderEXT *>( &shader ), allocator, result ); 23145 } 23146 getBinaryData() const23147 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ShaderEXT::getBinaryData() const 23148 { 23149 VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderBinaryDataEXT && "Function <vkGetShaderBinaryDataEXT> requires <VK_EXT_shader_object>" ); 23150 23151 std::vector<uint8_t> data; 23152 size_t dataSize; 23153 VULKAN_HPP_NAMESPACE::Result result; 23154 do 23155 { 23156 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 23157 getDispatcher()->vkGetShaderBinaryDataEXT( static_cast<VkDevice>( m_device ), static_cast<VkShaderEXT>( m_shader ), &dataSize, nullptr ) ); 23158 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) 23159 { 23160 data.resize( dataSize ); 23161 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetShaderBinaryDataEXT( 23162 static_cast<VkDevice>( m_device ), static_cast<VkShaderEXT>( m_shader ), &dataSize, reinterpret_cast<void *>( data.data() ) ) ); 23163 } 23164 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 23165 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ShaderEXT::getBinaryData" ); 23166 VULKAN_HPP_ASSERT( dataSize <= data.size() ); 23167 if ( dataSize < data.size() ) 23168 { 23169 data.resize( dataSize ); 23170 } 23171 return data; 23172 } 23173 bindShadersEXT(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages,VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & shaders) const23174 VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages, 23175 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & shaders ) const 23176 { 23177 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadersEXT && "Function <vkCmdBindShadersEXT> requires <VK_EXT_shader_object>" ); 23178 # ifdef VULKAN_HPP_NO_EXCEPTIONS 23179 VULKAN_HPP_ASSERT( stages.size() == shaders.size() ); 23180 # else 23181 if ( stages.size() != shaders.size() ) 23182 { 23183 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" ); 23184 } 23185 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/ 23186 23187 getDispatcher()->vkCmdBindShadersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 23188 stages.size(), 23189 reinterpret_cast<const VkShaderStageFlagBits *>( stages.data() ), 23190 reinterpret_cast<const VkShaderEXT *>( shaders.data() ) ); 23191 } 23192 23193 //=== VK_KHR_pipeline_binary === 23194 23195 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE 23196 VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR>>::Type createPipelineBinariesKHR(VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & createInfo,VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const23197 Device::createPipelineBinariesKHR( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & createInfo, 23198 VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const 23199 { 23200 std::vector<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR> pipelineBinaries; 23201 VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR binaries; 23202 VULKAN_HPP_NAMESPACE::Result result; 23203 if ( createInfo.pKeysAndDataInfo ) 23204 { 23205 VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); 23206 pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); 23207 binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; 23208 binaries.pPipelineBinaries = pipelineBinaries.data(); 23209 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineBinariesKHR( 23210 static_cast<VkDevice>( m_device ), 23211 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ), 23212 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 23213 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) ); 23214 } 23215 else 23216 { 23217 VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); 23218 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineBinariesKHR( 23219 static_cast<VkDevice>( m_device ), 23220 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ), 23221 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 23222 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) ); 23223 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 23224 { 23225 pipelineBinaries.resize( binaries.pipelineBinaryCount ); 23226 binaries.pPipelineBinaries = pipelineBinaries.data(); 23227 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineBinariesKHR( 23228 static_cast<VkDevice>( m_device ), 23229 reinterpret_cast<const VkPipelineBinaryCreateInfoKHR *>( &createInfo ), 23230 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), 23231 reinterpret_cast<VkPipelineBinaryHandlesInfoKHR *>( &binaries ) ) ); 23232 } 23233 } 23234 23235 if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncomplete ) && 23236 ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineBinaryMissingKHR ) ) 23237 { 23238 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) 23239 return VULKAN_HPP_UNEXPECTED( result ); 23240 # else 23241 VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPipelineBinariesKHR" ); 23242 # endif 23243 } 23244 23245 std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR> pipelineBinariesRAII; 23246 pipelineBinariesRAII.reserve( pipelineBinaries.size() ); 23247 for ( auto & pipelineBinary : pipelineBinaries ) 23248 { 23249 pipelineBinariesRAII.emplace_back( *this, *reinterpret_cast<VkPipelineBinaryKHR *>( &pipelineBinary ), allocator, result ); 23250 } 23251 return pipelineBinariesRAII; 23252 } 23253 23254 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR getPipelineKeyKHR(Optional<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> pipelineCreateInfo) const23255 Device::getPipelineKeyKHR( Optional<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR> pipelineCreateInfo ) const 23256 { 23257 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineKeyKHR && "Function <vkGetPipelineKeyKHR> requires <VK_KHR_pipeline_binary>" ); 23258 23259 VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR pipelineKey; 23260 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineKeyKHR( 23261 static_cast<VkDevice>( m_device ), 23262 reinterpret_cast<const VkPipelineCreateInfoKHR *>( static_cast<const VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR *>( pipelineCreateInfo ) ), 23263 reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineKey ) ) ); 23264 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineKeyKHR" ); 23265 23266 return pipelineKey; 23267 } 23268 23269 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t>> getPipelineBinaryDataKHR(const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info) const23270 Device::getPipelineBinaryDataKHR( const VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR & info ) const 23271 { 23272 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineBinaryDataKHR && "Function <vkGetPipelineBinaryDataKHR> requires <VK_KHR_pipeline_binary>" ); 23273 23274 std::pair<VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR, std::vector<uint8_t>> data_; 23275 VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first; 23276 std::vector<uint8_t> & pipelineBinaryData = data_.second; 23277 size_t pipelineBinaryDataSize; 23278 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 23279 getDispatcher()->vkGetPipelineBinaryDataKHR( static_cast<VkDevice>( m_device ), 23280 reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ), 23281 reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ), 23282 &pipelineBinaryDataSize, 23283 nullptr ) ); 23284 if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) 23285 { 23286 pipelineBinaryData.resize( pipelineBinaryDataSize ); 23287 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 23288 getDispatcher()->vkGetPipelineBinaryDataKHR( static_cast<VkDevice>( m_device ), 23289 reinterpret_cast<const VkPipelineBinaryDataInfoKHR *>( &info ), 23290 reinterpret_cast<VkPipelineBinaryKeyKHR *>( &pipelineBinaryKey ), 23291 &pipelineBinaryDataSize, 23292 reinterpret_cast<void *>( pipelineBinaryData.data() ) ) ); 23293 } 23294 23295 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" ); 23296 23297 return data_; 23298 } 23299 23300 VULKAN_HPP_INLINE void releaseCapturedPipelineDataKHR(const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR & info,Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator) const23301 Device::releaseCapturedPipelineDataKHR( const VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR & info, 23302 Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT 23303 { 23304 VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseCapturedPipelineDataKHR && "Function <vkReleaseCapturedPipelineDataKHR> requires <VK_KHR_pipeline_binary>" ); 23305 23306 getDispatcher()->vkReleaseCapturedPipelineDataKHR( 23307 static_cast<VkDevice>( m_device ), 23308 reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR *>( &info ), 23309 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) ); 23310 } 23311 23312 //=== VK_QCOM_tile_properties === 23313 getTilePropertiesQCOM() const23314 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> Framebuffer::getTilePropertiesQCOM() const 23315 { 23316 VULKAN_HPP_ASSERT( getDispatcher()->vkGetFramebufferTilePropertiesQCOM && 23317 "Function <vkGetFramebufferTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" ); 23318 23319 std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> properties; 23320 uint32_t propertiesCount; 23321 VULKAN_HPP_NAMESPACE::Result result; 23322 do 23323 { 23324 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFramebufferTilePropertiesQCOM( 23325 static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( m_framebuffer ), &propertiesCount, nullptr ) ); 23326 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertiesCount ) 23327 { 23328 properties.resize( propertiesCount ); 23329 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 23330 getDispatcher()->vkGetFramebufferTilePropertiesQCOM( static_cast<VkDevice>( m_device ), 23331 static_cast<VkFramebuffer>( m_framebuffer ), 23332 &propertiesCount, 23333 reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) ); 23334 } 23335 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 23336 23337 VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); 23338 if ( propertiesCount < properties.size() ) 23339 { 23340 properties.resize( propertiesCount ); 23341 } 23342 return properties; 23343 } 23344 23345 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::TilePropertiesQCOM getDynamicRenderingTilePropertiesQCOM(const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo) const23346 Device::getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT 23347 { 23348 VULKAN_HPP_ASSERT( getDispatcher()->vkGetDynamicRenderingTilePropertiesQCOM && 23349 "Function <vkGetDynamicRenderingTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" ); 23350 23351 VULKAN_HPP_NAMESPACE::TilePropertiesQCOM properties; 23352 getDispatcher()->vkGetDynamicRenderingTilePropertiesQCOM( static_cast<VkDevice>( m_device ), 23353 reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ), 23354 reinterpret_cast<VkTilePropertiesQCOM *>( &properties ) ); 23355 23356 return properties; 23357 } 23358 23359 //=== VK_NV_low_latency2 === 23360 setLatencySleepModeNV(const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo) const23361 VULKAN_HPP_INLINE void SwapchainKHR::setLatencySleepModeNV( const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo ) const 23362 { 23363 VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencySleepModeNV && "Function <vkSetLatencySleepModeNV> requires <VK_NV_low_latency2>" ); 23364 23365 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetLatencySleepModeNV( 23366 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( &sleepModeInfo ) ) ); 23367 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::setLatencySleepModeNV" ); 23368 } 23369 latencySleepNV(const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo) const23370 VULKAN_HPP_INLINE void SwapchainKHR::latencySleepNV( const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo ) const VULKAN_HPP_NOEXCEPT 23371 { 23372 VULKAN_HPP_ASSERT( getDispatcher()->vkLatencySleepNV && "Function <vkLatencySleepNV> requires <VK_NV_low_latency2>" ); 23373 23374 getDispatcher()->vkLatencySleepNV( 23375 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( &sleepInfo ) ); 23376 } 23377 setLatencyMarkerNV(const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo) const23378 VULKAN_HPP_INLINE void SwapchainKHR::setLatencyMarkerNV( const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT 23379 { 23380 VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencyMarkerNV && "Function <vkSetLatencyMarkerNV> requires <VK_NV_low_latency2>" ); 23381 23382 getDispatcher()->vkSetLatencyMarkerNV( static_cast<VkDevice>( m_device ), 23383 static_cast<VkSwapchainKHR>( m_swapchain ), 23384 reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) ); 23385 } 23386 getLatencyTimingsNV() const23387 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV> SwapchainKHR::getLatencyTimingsNV() const 23388 { 23389 VULKAN_HPP_ASSERT( getDispatcher()->vkGetLatencyTimingsNV && "Function <vkGetLatencyTimingsNV> requires <VK_NV_low_latency2>" ); 23390 23391 std::vector<VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV> timings; 23392 VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV latencyMarkerInfo; 23393 getDispatcher()->vkGetLatencyTimingsNV( 23394 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) ); 23395 timings.resize( latencyMarkerInfo.timingCount ); 23396 latencyMarkerInfo.pTimings = timings.data(); 23397 getDispatcher()->vkGetLatencyTimingsNV( 23398 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) ); 23399 23400 return timings; 23401 } 23402 notifyOutOfBandNV(const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo) const23403 VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT 23404 { 23405 VULKAN_HPP_ASSERT( getDispatcher()->vkQueueNotifyOutOfBandNV && "Function <vkQueueNotifyOutOfBandNV> requires <VK_NV_low_latency2>" ); 23406 23407 getDispatcher()->vkQueueNotifyOutOfBandNV( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( &queueTypeInfo ) ); 23408 } 23409 23410 //=== VK_KHR_cooperative_matrix === 23411 23412 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> getCooperativeMatrixPropertiesKHR() const23413 PhysicalDevice::getCooperativeMatrixPropertiesKHR() const 23414 { 23415 VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR && 23416 "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR> requires <VK_KHR_cooperative_matrix>" ); 23417 23418 std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> properties; 23419 uint32_t propertyCount; 23420 VULKAN_HPP_NAMESPACE::Result result; 23421 do 23422 { 23423 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 23424 getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) ); 23425 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) 23426 { 23427 properties.resize( propertyCount ); 23428 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( 23429 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( properties.data() ) ) ); 23430 } 23431 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 23432 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" ); 23433 VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); 23434 if ( propertyCount < properties.size() ) 23435 { 23436 properties.resize( propertyCount ); 23437 } 23438 return properties; 23439 } 23440 23441 //=== VK_EXT_attachment_feedback_loop_dynamic_state === 23442 setAttachmentFeedbackLoopEnableEXT(VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask) const23443 VULKAN_HPP_INLINE void CommandBuffer::setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT 23444 { 23445 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAttachmentFeedbackLoopEnableEXT && 23446 "Function <vkCmdSetAttachmentFeedbackLoopEnableEXT> requires <VK_EXT_attachment_feedback_loop_dynamic_state>" ); 23447 23448 getDispatcher()->vkCmdSetAttachmentFeedbackLoopEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 23449 static_cast<VkImageAspectFlags>( aspectMask ) ); 23450 } 23451 23452 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 23453 //=== VK_QNX_external_memory_screen_buffer === 23454 23455 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX getScreenBufferPropertiesQNX(const struct _screen_buffer & buffer) const23456 Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const 23457 { 23458 VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX && 23459 "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" ); 23460 23461 VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX properties; 23462 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetScreenBufferPropertiesQNX( 23463 static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( &properties ) ) ); 23464 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); 23465 23466 return properties; 23467 } 23468 23469 template <typename X, typename Y, typename... Z> 23470 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getScreenBufferPropertiesQNX(const struct _screen_buffer & buffer) const23471 Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const 23472 { 23473 VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX && 23474 "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" ); 23475 23476 StructureChain<X, Y, Z...> structureChain; 23477 VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>(); 23478 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetScreenBufferPropertiesQNX( 23479 static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( &properties ) ) ); 23480 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); 23481 23482 return structureChain; 23483 } 23484 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 23485 23486 //=== VK_KHR_line_rasterization === 23487 setLineStippleKHR(uint32_t lineStippleFactor,uint16_t lineStipplePattern) const23488 VULKAN_HPP_INLINE void CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT 23489 { 23490 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleKHR && 23491 "Function <vkCmdSetLineStippleKHR> requires <VK_EXT_line_rasterization> or <VK_KHR_line_rasterization> or <VK_VERSION_1_4>" ); 23492 23493 getDispatcher()->vkCmdSetLineStippleKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); 23494 } 23495 23496 //=== VK_KHR_calibrated_timestamps === 23497 getCalibrateableTimeDomainsKHR() const23498 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> PhysicalDevice::getCalibrateableTimeDomainsKHR() const 23499 { 23500 VULKAN_HPP_ASSERT( 23501 getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR && 23502 "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); 23503 23504 std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> timeDomains; 23505 uint32_t timeDomainCount; 23506 VULKAN_HPP_NAMESPACE::Result result; 23507 do 23508 { 23509 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 23510 getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr ) ); 23511 if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount ) 23512 { 23513 timeDomains.resize( timeDomainCount ); 23514 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( 23515 static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) ); 23516 } 23517 } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); 23518 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" ); 23519 VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); 23520 if ( timeDomainCount < timeDomains.size() ) 23521 { 23522 timeDomains.resize( timeDomainCount ); 23523 } 23524 return timeDomains; 23525 } 23526 getCalibratedTimestampsKHR(VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos) const23527 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t> Device::getCalibratedTimestampsKHR( 23528 VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const 23529 { 23530 VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR && 23531 "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); 23532 23533 std::pair<std::vector<uint64_t>, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); 23534 std::vector<uint64_t> & timestamps = data_.first; 23535 uint64_t & maxDeviation = data_.second; 23536 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( 23537 getDispatcher()->vkGetCalibratedTimestampsKHR( static_cast<VkDevice>( m_device ), 23538 timestampInfos.size(), 23539 reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ), 23540 timestamps.data(), 23541 &maxDeviation ) ); 23542 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); 23543 23544 return data_; 23545 } 23546 23547 VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t> getCalibratedTimestampKHR(const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo) const23548 Device::getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const 23549 { 23550 VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR && 23551 "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" ); 23552 23553 std::pair<uint64_t, uint64_t> data_; 23554 uint64_t & timestamp = data_.first; 23555 uint64_t & maxDeviation = data_.second; 23556 VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsKHR( 23557 static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( ×tampInfo ), ×tamp, &maxDeviation ) ); 23558 VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" ); 23559 23560 return data_; 23561 } 23562 23563 //=== VK_KHR_maintenance6 === 23564 23565 VULKAN_HPP_INLINE void bindDescriptorSets2KHR(const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo) const23566 CommandBuffer::bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT 23567 { 23568 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets2KHR && 23569 "Function <vkCmdBindDescriptorSets2KHR> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" ); 23570 23571 getDispatcher()->vkCmdBindDescriptorSets2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 23572 reinterpret_cast<const VkBindDescriptorSetsInfo *>( &bindDescriptorSetsInfo ) ); 23573 } 23574 pushConstants2KHR(const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo) const23575 VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT 23576 { 23577 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants2KHR && "Function <vkCmdPushConstants2KHR> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" ); 23578 23579 getDispatcher()->vkCmdPushConstants2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 23580 reinterpret_cast<const VkPushConstantsInfo *>( &pushConstantsInfo ) ); 23581 } 23582 23583 VULKAN_HPP_INLINE void pushDescriptorSet2KHR(const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo) const23584 CommandBuffer::pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT 23585 { 23586 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet2KHR && 23587 "Function <vkCmdPushDescriptorSet2KHR> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" ); 23588 23589 getDispatcher()->vkCmdPushDescriptorSet2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), 23590 reinterpret_cast<const VkPushDescriptorSetInfo *>( &pushDescriptorSetInfo ) ); 23591 } 23592 pushDescriptorSetWithTemplate2KHR(const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo) const23593 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2KHR( 23594 const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT 23595 { 23596 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetWithTemplate2KHR && 23597 "Function <vkCmdPushDescriptorSetWithTemplate2KHR> requires <VK_KHR_maintenance6> or <VK_VERSION_1_4>" ); 23598 23599 getDispatcher()->vkCmdPushDescriptorSetWithTemplate2KHR( 23600 static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPushDescriptorSetWithTemplateInfo *>( &pushDescriptorSetWithTemplateInfo ) ); 23601 } 23602 setDescriptorBufferOffsets2EXT(const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo) const23603 VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsets2EXT( 23604 const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT 23605 { 23606 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDescriptorBufferOffsets2EXT && 23607 "Function <vkCmdSetDescriptorBufferOffsets2EXT> requires <VK_KHR_maintenance6>" ); 23608 23609 getDispatcher()->vkCmdSetDescriptorBufferOffsets2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), 23610 reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT *>( &setDescriptorBufferOffsetsInfo ) ); 23611 } 23612 bindDescriptorBufferEmbeddedSamplers2EXT(const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo) const23613 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( 23614 const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT 23615 { 23616 VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplers2EXT && 23617 "Function <vkCmdBindDescriptorBufferEmbeddedSamplers2EXT> requires <VK_KHR_maintenance6>" ); 23618 23619 getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( 23620 static_cast<VkCommandBuffer>( m_commandBuffer ), 23621 reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( &bindDescriptorBufferEmbeddedSamplersInfo ) ); 23622 } 23623 23624 //==================== 23625 //=== RAII Helpers === 23626 //==================== 23627 23628 template <typename RAIIType> filterCppTypes(std::vector<RAIIType> const & raiiTypes)23629 std::vector<typename RAIIType::CppType> filterCppTypes( std::vector<RAIIType> const & raiiTypes ) 23630 { 23631 std::vector<typename RAIIType::CppType> cppTypes( raiiTypes.size() ); 23632 std::transform( raiiTypes.begin(), raiiTypes.end(), cppTypes.begin(), []( RAIIType const & d ) { return *d; } ); 23633 return cppTypes; 23634 } 23635 23636 template <typename RAIIType, class UnaryPredicate> filterCppTypes(std::vector<RAIIType> const & raiiTypes,UnaryPredicate p)23637 std::vector<typename RAIIType::CppType> filterCppTypes( std::vector<RAIIType> const & raiiTypes, UnaryPredicate p ) 23638 { 23639 std::vector<typename RAIIType::CppType> cppTypes; 23640 for ( auto const & t : raiiTypes ) 23641 { 23642 if ( p( t ) ) 23643 { 23644 cppTypes.push_back( *t ); 23645 } 23646 } 23647 return cppTypes; 23648 } 23649 23650 } // namespace VULKAN_HPP_RAII_NAMESPACE 23651 } // namespace VULKAN_HPP_NAMESPACE 23652 #endif 23653 #endif 23654