HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
vulkan_raii.hpp
Go to the documentation of this file.
1 // Copyright 2015-2022 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 <memory>
12 #include <utility> // std::exchange, std::forward
13 #include <vulkan/vulkan.hpp>
14 
15 #if !defined( VULKAN_HPP_RAII_NAMESPACE )
16 # define VULKAN_HPP_RAII_NAMESPACE raii
17 #endif
18 
19 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) && !defined( VULKAN_HPP_NO_EXCEPTIONS )
20 namespace VULKAN_HPP_NAMESPACE
21 {
23  {
24  template <class T, class U = T>
26  {
27 # if ( 14 <= VULKAN_HPP_CPP_VERSION )
28  return std::exchange<T>( obj, std::forward<U>( newValue ) );
29 # else
30  T oldValue = std::move( obj );
31  obj = std::forward<U>( newValue );
32  return oldValue;
33 # endif
34  }
35 
37  {
38  public:
40  : vkGetInstanceProcAddr( getProcAddr )
41  //=== VK_VERSION_1_0 ===
42  , vkCreateInstance( PFN_vkCreateInstance( getProcAddr( NULL, "vkCreateInstance" ) ) )
43  , vkEnumerateInstanceExtensionProperties( PFN_vkEnumerateInstanceExtensionProperties( getProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) ) )
44  , vkEnumerateInstanceLayerProperties( PFN_vkEnumerateInstanceLayerProperties( getProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) ) )
45  //=== VK_VERSION_1_1 ===
46  , vkEnumerateInstanceVersion( PFN_vkEnumerateInstanceVersion( getProcAddr( NULL, "vkEnumerateInstanceVersion" ) ) )
47  {
48  }
49 
50  public:
52 
53  //=== VK_VERSION_1_0 ===
57 
58  //=== VK_VERSION_1_1 ===
60  };
61 
63  {
64  public:
65  InstanceDispatcher( PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance ) : vkGetInstanceProcAddr( getProcAddr )
66  {
67  //=== VK_VERSION_1_0 ===
68  vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) );
69  vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) );
70  vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) );
72  PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) );
74  PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) );
75  vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) );
77  PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) );
79  PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) );
80  vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) );
82  PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) );
83  vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) );
85  PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) );
86 
87  //=== VK_VERSION_1_1 ===
88  vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) );
89  vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) );
90  vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
92  PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) );
94  PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) );
96  PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
98  PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) );
100  PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) );
102  PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) );
104  PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) );
106  PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) );
107 
108  //=== VK_VERSION_1_3 ===
109  vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) );
110 
111  //=== VK_EXT_acquire_drm_display ===
112  vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) );
113  vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) );
114 
115 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
116  //=== VK_EXT_acquire_xlib_display ===
117  vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
118  vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
119 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
120 
121  //=== VK_EXT_calibrated_timestamps ===
123  PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
124 
125  //=== VK_EXT_debug_report ===
126  vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) );
127  vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) );
128  vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) );
129 
130  //=== VK_EXT_debug_utils ===
131  vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) );
132  vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) );
133  vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
134 
135  //=== VK_EXT_direct_mode_display ===
136  vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
137 
138 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
139  //=== VK_EXT_directfb_surface ===
140  vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) );
142  PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) );
143 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
144 
145  //=== VK_EXT_display_surface_counter ===
147  PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) );
148 
149 # if defined( VK_USE_PLATFORM_WIN32_KHR )
150  //=== VK_EXT_full_screen_exclusive ===
152  PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) );
153 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
154 
155  //=== VK_EXT_headless_surface ===
156  vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) );
157 
158 # if defined( VK_USE_PLATFORM_METAL_EXT )
159  //=== VK_EXT_metal_surface ===
160  vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) );
161 # endif /*VK_USE_PLATFORM_METAL_EXT*/
162 
163  //=== VK_EXT_sample_locations ===
165  PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
166 
167  //=== VK_EXT_tooling_info ===
169  PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) );
172 
173 # if defined( VK_USE_PLATFORM_FUCHSIA )
174  //=== VK_FUCHSIA_imagepipe_surface ===
175  vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) );
176 # endif /*VK_USE_PLATFORM_FUCHSIA*/
177 
178 # if defined( VK_USE_PLATFORM_GGP )
179  //=== VK_GGP_stream_descriptor_surface ===
180  vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) );
181 # endif /*VK_USE_PLATFORM_GGP*/
182 
183 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
184  //=== VK_KHR_android_surface ===
185  vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
186 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
187 
188  //=== VK_KHR_device_group ===
190  PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) );
191 
192  //=== VK_KHR_device_group_creation ===
193  vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) );
196 
197  //=== VK_KHR_display ===
199  PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) );
201  PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) );
203  PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) );
204  vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) );
205  vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
206  vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) );
207  vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) );
208 
209  //=== VK_KHR_external_fence_capabilities ===
211  PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) );
214 
215  //=== VK_KHR_external_memory_capabilities ===
217  PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) );
220 
221  //=== VK_KHR_external_semaphore_capabilities ===
223  PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) );
226 
227  //=== VK_KHR_fragment_shading_rate ===
229  PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
230 
231  //=== VK_KHR_get_display_properties2 ===
233  PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) );
235  PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) );
236  vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) );
237  vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) );
238 
239  //=== VK_KHR_get_physical_device_properties2 ===
240  vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) );
243  vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) );
247  PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) );
251  PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) );
255  PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) );
259  PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) );
263  PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) );
266 
267  //=== VK_KHR_get_surface_capabilities2 ===
269  PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) );
271  PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) );
272 
273  //=== VK_KHR_performance_query ===
275  vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
277  vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) );
278 
279  //=== VK_KHR_surface ===
280  vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) );
282  PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) );
284  PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) );
286  PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) );
288  PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) );
289 
290 # if defined( VK_ENABLE_BETA_EXTENSIONS )
291  //=== VK_KHR_video_queue ===
293  PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) );
295  PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) );
296 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
297 
298 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
299  //=== VK_KHR_wayland_surface ===
300  vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) );
302  PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) );
303 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
304 
305 # if defined( VK_USE_PLATFORM_WIN32_KHR )
306  //=== VK_KHR_win32_surface ===
307  vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) );
309  PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) );
310 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
311 
312 # if defined( VK_USE_PLATFORM_XCB_KHR )
313  //=== VK_KHR_xcb_surface ===
314  vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) );
316  PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) );
317 # endif /*VK_USE_PLATFORM_XCB_KHR*/
318 
319 # if defined( VK_USE_PLATFORM_XLIB_KHR )
320  //=== VK_KHR_xlib_surface ===
321  vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) );
323  PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) );
324 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
325 
326 # if defined( VK_USE_PLATFORM_IOS_MVK )
327  //=== VK_MVK_ios_surface ===
328  vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) );
329 # endif /*VK_USE_PLATFORM_IOS_MVK*/
330 
331 # if defined( VK_USE_PLATFORM_MACOS_MVK )
332  //=== VK_MVK_macos_surface ===
333  vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) );
334 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
335 
336 # if defined( VK_USE_PLATFORM_VI_NN )
337  //=== VK_NN_vi_surface ===
338  vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) );
339 # endif /*VK_USE_PLATFORM_VI_NN*/
340 
341 # if defined( VK_USE_PLATFORM_WIN32_KHR )
342  //=== VK_NV_acquire_winrt_display ===
343  vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
344  vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
345 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
346 
347  //=== VK_NV_cooperative_matrix ===
349  PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) );
350 
351  //=== VK_NV_coverage_reduction_mode ===
353  vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) );
354 
355  //=== VK_NV_external_memory_capabilities ===
357  PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) );
358 
359  //=== VK_NV_optical_flow ===
361  PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) );
362 
363 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
364  //=== VK_QNX_screen_surface ===
365  vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) );
367  PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) );
368 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
369 
370  vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
371  }
372 
373  public:
374  //=== VK_VERSION_1_0 ===
388 
389  //=== VK_VERSION_1_1 ===
401 
402  //=== VK_VERSION_1_3 ===
404 
405  //=== VK_EXT_acquire_drm_display ===
408 
409 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
410  //=== VK_EXT_acquire_xlib_display ===
413 # else
416 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
417 
418  //=== VK_EXT_calibrated_timestamps ===
420 
421  //=== VK_EXT_debug_report ===
425 
426  //=== VK_EXT_debug_utils ===
430 
431  //=== VK_EXT_direct_mode_display ===
433 
434 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
435  //=== VK_EXT_directfb_surface ===
438 # else
441 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
442 
443  //=== VK_EXT_display_surface_counter ===
445 
446 # if defined( VK_USE_PLATFORM_WIN32_KHR )
447  //=== VK_EXT_full_screen_exclusive ===
449 # else
451 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
452 
453  //=== VK_EXT_headless_surface ===
455 
456 # if defined( VK_USE_PLATFORM_METAL_EXT )
457  //=== VK_EXT_metal_surface ===
459 # else
461 # endif /*VK_USE_PLATFORM_METAL_EXT*/
462 
463  //=== VK_EXT_sample_locations ===
465 
466  //=== VK_EXT_tooling_info ===
468 
469 # if defined( VK_USE_PLATFORM_FUCHSIA )
470  //=== VK_FUCHSIA_imagepipe_surface ===
472 # else
474 # endif /*VK_USE_PLATFORM_FUCHSIA*/
475 
476 # if defined( VK_USE_PLATFORM_GGP )
477  //=== VK_GGP_stream_descriptor_surface ===
479 # else
481 # endif /*VK_USE_PLATFORM_GGP*/
482 
483 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
484  //=== VK_KHR_android_surface ===
486 # else
488 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
489 
490  //=== VK_KHR_device_group ===
492 
493  //=== VK_KHR_device_group_creation ===
495 
496  //=== VK_KHR_display ===
504 
505  //=== VK_KHR_external_fence_capabilities ===
507 
508  //=== VK_KHR_external_memory_capabilities ===
510 
511  //=== VK_KHR_external_semaphore_capabilities ===
513 
514  //=== VK_KHR_fragment_shading_rate ===
516 
517  //=== VK_KHR_get_display_properties2 ===
522 
523  //=== VK_KHR_get_physical_device_properties2 ===
531 
532  //=== VK_KHR_get_surface_capabilities2 ===
535 
536  //=== VK_KHR_performance_query ===
539 
540  //=== VK_KHR_surface ===
546 
547 # if defined( VK_ENABLE_BETA_EXTENSIONS )
548  //=== VK_KHR_video_queue ===
551 # else
554 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
555 
556 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
557  //=== VK_KHR_wayland_surface ===
560 # else
563 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
564 
565 # if defined( VK_USE_PLATFORM_WIN32_KHR )
566  //=== VK_KHR_win32_surface ===
569 # else
572 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
573 
574 # if defined( VK_USE_PLATFORM_XCB_KHR )
575  //=== VK_KHR_xcb_surface ===
578 # else
581 # endif /*VK_USE_PLATFORM_XCB_KHR*/
582 
583 # if defined( VK_USE_PLATFORM_XLIB_KHR )
584  //=== VK_KHR_xlib_surface ===
587 # else
590 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
591 
592 # if defined( VK_USE_PLATFORM_IOS_MVK )
593  //=== VK_MVK_ios_surface ===
595 # else
597 # endif /*VK_USE_PLATFORM_IOS_MVK*/
598 
599 # if defined( VK_USE_PLATFORM_MACOS_MVK )
600  //=== VK_MVK_macos_surface ===
602 # else
604 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
605 
606 # if defined( VK_USE_PLATFORM_VI_NN )
607  //=== VK_NN_vi_surface ===
609 # else
611 # endif /*VK_USE_PLATFORM_VI_NN*/
612 
613 # if defined( VK_USE_PLATFORM_WIN32_KHR )
614  //=== VK_NV_acquire_winrt_display ===
617 # else
620 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
621 
622  //=== VK_NV_cooperative_matrix ===
624 
625  //=== VK_NV_coverage_reduction_mode ===
627 
628  //=== VK_NV_external_memory_capabilities ===
630 
631  //=== VK_NV_optical_flow ===
633 
634 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
635  //=== VK_QNX_screen_surface ===
638 # else
641 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
642 
644  };
645 
647  {
648  public:
649  DeviceDispatcher( PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device ) : vkGetDeviceProcAddr( getProcAddr )
650  {
651  //=== VK_VERSION_1_0 ===
652  vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
653  vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) );
654  vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) );
655  vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) );
656  vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) );
657  vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) );
658  vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
659  vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) );
660  vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) );
661  vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
662  vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) );
663  vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) );
664  vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) );
665  vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
666  vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
667  vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) );
668  vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) );
669  vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) );
670  vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) );
671  vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) );
672  vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) );
673  vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
674  vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) );
675  vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
676  vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) );
677  vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) );
678  vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) );
679  vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) );
680  vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) );
681  vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
682  vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
683  vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) );
684  vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) );
685  vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) );
686  vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) );
687  vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
688  vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) );
689  vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
690  vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) );
691  vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) );
692  vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
693  vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) );
694  vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) );
695  vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) );
696  vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) );
697  vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) );
698  vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) );
699  vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) );
700  vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) );
701  vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) );
702  vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) );
703  vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) );
704  vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) );
705  vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) );
706  vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
707  vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) );
708  vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) );
709  vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) );
710  vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
711  vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) );
712  vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
713  vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
714  vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) );
715  vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
716  vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) );
717  vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) );
718  vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) );
719  vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) );
720  vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) );
721  vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) );
722  vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) );
723  vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
724  vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
725  vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) );
726  vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
727  vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
728  vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
729  vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) );
730  vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) );
731  vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) );
732  vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
733  vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
734  vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) );
735  vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
736  vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) );
737  vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) );
738  vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) );
739  vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) );
740  vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) );
741  vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) );
742  vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) );
743  vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) );
744  vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) );
745  vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) );
746  vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
747  vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) );
748  vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) );
749  vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) );
750  vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) );
751  vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) );
752  vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) );
753  vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) );
754  vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) );
755  vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) );
756  vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) );
757  vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) );
758  vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) );
759  vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
760  vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) );
761  vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) );
762  vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) );
763  vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) );
764  vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) );
765  vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) );
766  vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
767  vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) );
768  vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) );
769  vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
770  vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) );
771  vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) );
772  vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) );
773 
774  //=== VK_VERSION_1_1 ===
775  vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
776  vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
777  vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
778  vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
779  vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
780  vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
781  vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
782  vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
783  vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) );
784  vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) );
785  vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
786  vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
787  vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) );
788  vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) );
789  vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) );
790  vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
791 
792  //=== VK_VERSION_1_2 ===
793  vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) );
794  vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) );
795  vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) );
796  vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) );
797  vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) );
798  vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) );
799  vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) );
800  vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) );
801  vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) );
802  vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) );
803  vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) );
804  vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) );
806  PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
807 
808  //=== VK_VERSION_1_3 ===
809  vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) );
810  vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) );
811  vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) );
812  vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) );
813  vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) );
814  vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) );
815  vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) );
816  vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) );
817  vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) );
818  vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) );
819  vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) );
820  vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) );
821  vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) );
822  vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) );
823  vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) );
824  vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) );
825  vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) );
826  vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) );
827  vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) );
828  vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) );
829  vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) );
830  vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) );
831  vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) );
832  vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) );
833  vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) );
834  vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) );
835  vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) );
836  vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) );
837  vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) );
838  vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) );
839  vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) );
840  vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) );
841  vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) );
842  vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) );
843  vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) );
845  PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) );
846 
847  //=== VK_AMD_buffer_marker ===
848  vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) );
849 
850  //=== VK_AMD_display_native_hdr ===
851  vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) );
852 
853  //=== VK_AMD_draw_indirect_count ===
854  vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
855  if ( !vkCmdDrawIndirectCount )
857  vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) );
860 
861  //=== VK_AMD_shader_info ===
862  vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) );
863 
864 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
865  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
867  PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
869  PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
870 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
871 
872  //=== VK_EXT_buffer_device_address ===
873  vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
876 
877  //=== VK_EXT_calibrated_timestamps ===
878  vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
879 
880  //=== VK_EXT_color_write_enable ===
881  vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) );
882 
883  //=== VK_EXT_conditional_rendering ===
884  vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
885  vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) );
886 
887  //=== VK_EXT_debug_marker ===
888  vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) );
889  vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) );
890  vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) );
891  vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) );
892  vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) );
893 
894  //=== VK_EXT_debug_utils ===
895  vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
896  vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
897  vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) );
898  vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) );
899  vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) );
900  vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
901  vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) );
902  vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) );
903 
904  //=== VK_EXT_descriptor_buffer ===
905  vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) );
907  PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
908  vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) );
909  vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) );
910  vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
912  PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
914  PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
916  PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
918  PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
920  PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
922  vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
923 
924  //=== VK_EXT_device_fault ===
925  vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) );
926 
927  //=== VK_EXT_discard_rectangles ===
928  vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
929 
930  //=== VK_EXT_display_control ===
931  vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
932  vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
933  vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
934  vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) );
935 
936  //=== VK_EXT_extended_dynamic_state ===
937  vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) );
938  if ( !vkCmdSetCullMode )
940  vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) );
941  if ( !vkCmdSetFrontFace )
943  vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) );
946  vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) );
949  vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) );
952  vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) );
955  vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) );
958  vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) );
961  vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) );
962  if ( !vkCmdSetDepthCompareOp )
964  vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) );
967  vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) );
970  vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) );
971  if ( !vkCmdSetStencilOp )
973 
974  //=== VK_EXT_extended_dynamic_state2 ===
975  vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) );
976  vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) );
979  vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) );
982  vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) );
983  vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) );
986 
987  //=== VK_EXT_extended_dynamic_state3 ===
988  vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
989  vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) );
990  vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) );
991  vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) );
992  vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) );
993  vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) );
994  vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) );
995  vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) );
996  vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) );
997  vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) );
998  vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) );
999  vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) );
1001  PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) );
1003  PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
1004  vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) );
1005  vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) );
1006  vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) );
1007  vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) );
1008  vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) );
1009  vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) );
1011  PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
1012  vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) );
1013  vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) );
1014  vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) );
1015  vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) );
1016  vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) );
1018  PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) );
1019  vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) );
1020  vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) );
1022  PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
1023  vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) );
1024 
1025  //=== VK_EXT_external_memory_host ===
1026  vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
1027 
1028 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1029  //=== VK_EXT_full_screen_exclusive ===
1030  vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) );
1031  vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
1033  PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
1034 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1035 
1036  //=== VK_EXT_hdr_metadata ===
1037  vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
1038 
1039  //=== VK_EXT_host_query_reset ===
1040  vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
1041  if ( !vkResetQueryPool )
1043 
1044  //=== VK_EXT_image_compression_control ===
1045  vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) );
1046 
1047  //=== VK_EXT_image_drm_format_modifier ===
1049  PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
1050 
1051  //=== VK_EXT_line_rasterization ===
1052  vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
1053 
1054  //=== VK_EXT_mesh_shader ===
1055  vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) );
1056  vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) );
1057  vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
1058 
1059 # if defined( VK_USE_PLATFORM_METAL_EXT )
1060  //=== VK_EXT_metal_objects ===
1061  vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) );
1062 # endif /*VK_USE_PLATFORM_METAL_EXT*/
1063 
1064  //=== VK_EXT_multi_draw ===
1065  vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) );
1066  vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) );
1067 
1068  //=== VK_EXT_opacity_micromap ===
1069  vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) );
1070  vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) );
1071  vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) );
1072  vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) );
1073  vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) );
1074  vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) );
1075  vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) );
1076  vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) );
1077  vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) );
1078  vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) );
1079  vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) );
1080  vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) );
1081  vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) );
1082  vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) );
1083 
1084  //=== VK_EXT_pageable_device_local_memory ===
1085  vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) );
1086 
1087  //=== VK_EXT_pipeline_properties ===
1088  vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) );
1089 
1090  //=== VK_EXT_private_data ===
1091  vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) );
1092  if ( !vkCreatePrivateDataSlot )
1094  vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) );
1095  if ( !vkDestroyPrivateDataSlot )
1097  vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) );
1098  if ( !vkSetPrivateData )
1100  vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) );
1101  if ( !vkGetPrivateData )
1103 
1104  //=== VK_EXT_sample_locations ===
1105  vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
1106 
1107  //=== VK_EXT_shader_module_identifier ===
1108  vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) );
1110  PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
1111 
1112  //=== VK_EXT_transform_feedback ===
1114  PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) );
1115  vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) );
1116  vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) );
1117  vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) );
1118  vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) );
1119  vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) );
1120 
1121  //=== VK_EXT_validation_cache ===
1122  vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) );
1123  vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) );
1124  vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) );
1125  vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) );
1126 
1127  //=== VK_EXT_vertex_input_dynamic_state ===
1128  vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) );
1129 
1130 # if defined( VK_USE_PLATFORM_FUCHSIA )
1131  //=== VK_FUCHSIA_buffer_collection ===
1132  vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) );
1134  PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
1136  PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
1137  vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) );
1139  PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
1140 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1141 
1142 # if defined( VK_USE_PLATFORM_FUCHSIA )
1143  //=== VK_FUCHSIA_external_memory ===
1144  vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) );
1146  PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
1147 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1148 
1149 # if defined( VK_USE_PLATFORM_FUCHSIA )
1150  //=== VK_FUCHSIA_external_semaphore ===
1152  PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
1153  vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
1154 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1155 
1156  //=== VK_GOOGLE_display_timing ===
1157  vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) );
1158  vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) );
1159 
1160  //=== VK_HUAWEI_invocation_mask ===
1161  vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) );
1162 
1163  //=== VK_HUAWEI_subpass_shading ===
1165  PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
1166  vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) );
1167 
1168  //=== VK_INTEL_performance_query ===
1169  vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) );
1170  vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) );
1171  vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) );
1173  PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
1174  vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) );
1176  PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
1178  PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
1180  PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) );
1181  vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) );
1182 
1183  //=== VK_KHR_acceleration_structure ===
1184  vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) );
1185  vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) );
1186  vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) );
1188  PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
1189  vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) );
1190  vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) );
1192  PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) );
1194  PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) );
1196  PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) );
1197  vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) );
1199  PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
1201  PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
1203  PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) );
1205  PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
1207  PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
1209  PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) );
1210 
1211  //=== VK_KHR_bind_memory2 ===
1212  vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) );
1213  if ( !vkBindBufferMemory2 )
1215  vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) );
1216  if ( !vkBindImageMemory2 )
1218 
1219  //=== VK_KHR_buffer_device_address ===
1220  vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) );
1221  if ( !vkGetBufferDeviceAddress )
1223  vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) );
1227  PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
1230 
1231  //=== VK_KHR_copy_commands2 ===
1232  vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) );
1233  if ( !vkCmdCopyBuffer2 )
1235  vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) );
1236  if ( !vkCmdCopyImage2 )
1238  vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) );
1239  if ( !vkCmdCopyBufferToImage2 )
1241  vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) );
1242  if ( !vkCmdCopyImageToBuffer2 )
1244  vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) );
1245  if ( !vkCmdBlitImage2 )
1247  vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) );
1248  if ( !vkCmdResolveImage2 )
1250 
1251  //=== VK_KHR_create_renderpass2 ===
1252  vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) );
1253  if ( !vkCreateRenderPass2 )
1255  vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) );
1256  if ( !vkCmdBeginRenderPass2 )
1258  vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) );
1259  if ( !vkCmdNextSubpass2 )
1261  vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) );
1262  if ( !vkCmdEndRenderPass2 )
1264 
1265  //=== VK_KHR_deferred_host_operations ===
1266  vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) );
1267  vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) );
1269  PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
1270  vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) );
1271  vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) );
1272 
1273  //=== VK_KHR_descriptor_update_template ===
1274  vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) );
1278  PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) );
1282  PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) );
1286  PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
1287 
1288  //=== VK_KHR_device_group ===
1290  PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
1293  vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) );
1294  if ( !vkCmdSetDeviceMask )
1296  vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) );
1297  if ( !vkCmdDispatchBase )
1300  PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
1302  PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
1303  vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
1304 
1305  //=== VK_KHR_display_swapchain ===
1306  vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) );
1307 
1308  //=== VK_KHR_draw_indirect_count ===
1309  vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) );
1310  if ( !vkCmdDrawIndirectCount )
1312  vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) );
1315 
1316  //=== VK_KHR_dynamic_rendering ===
1317  vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) );
1318  if ( !vkCmdBeginRendering )
1320  vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) );
1321  if ( !vkCmdEndRendering )
1323 
1324  //=== VK_KHR_external_fence_fd ===
1325  vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) );
1326  vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) );
1327 
1328 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1329  //=== VK_KHR_external_fence_win32 ===
1330  vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) );
1331  vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) );
1332 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1333 
1334  //=== VK_KHR_external_memory_fd ===
1335  vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) );
1336  vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) );
1337 
1338 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1339  //=== VK_KHR_external_memory_win32 ===
1340  vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) );
1341  vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) );
1342 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1343 
1344  //=== VK_KHR_external_semaphore_fd ===
1345  vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) );
1346  vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) );
1347 
1348 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1349  //=== VK_KHR_external_semaphore_win32 ===
1350  vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) );
1351  vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) );
1352 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1353 
1354  //=== VK_KHR_fragment_shading_rate ===
1355  vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
1356 
1357  //=== VK_KHR_get_memory_requirements2 ===
1358  vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) );
1361  vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) );
1365  PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) );
1368 
1369  //=== VK_KHR_maintenance1 ===
1370  vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) );
1371  if ( !vkTrimCommandPool )
1373 
1374  //=== VK_KHR_maintenance3 ===
1375  vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) );
1378 
1379  //=== VK_KHR_maintenance4 ===
1381  PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
1385  PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) );
1389  PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
1392 
1393  //=== VK_KHR_performance_query ===
1394  vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
1395  vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
1396 
1397  //=== VK_KHR_pipeline_executable_properties ===
1399  PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) );
1401  PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) );
1403  PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
1404 
1405  //=== VK_KHR_present_wait ===
1406  vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) );
1407 
1408  //=== VK_KHR_push_descriptor ===
1409  vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) );
1410 
1411  //=== VK_KHR_ray_tracing_maintenance1 ===
1412  vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) );
1413 
1414  //=== VK_KHR_ray_tracing_pipeline ===
1415  vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) );
1416  vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) );
1418  PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) );
1420  PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
1421  vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) );
1423  PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
1425  PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
1426 
1427  //=== VK_KHR_sampler_ycbcr_conversion ===
1428  vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) );
1431  vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) );
1434 
1435  //=== VK_KHR_shared_presentable_image ===
1436  vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) );
1437 
1438  //=== VK_KHR_swapchain ===
1439  vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) );
1440  vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) );
1441  vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) );
1442  vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
1443  vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) );
1444 
1445  //=== VK_KHR_synchronization2 ===
1446  vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) );
1447  if ( !vkCmdSetEvent2 )
1449  vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) );
1450  if ( !vkCmdResetEvent2 )
1452  vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) );
1453  if ( !vkCmdWaitEvents2 )
1455  vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) );
1456  if ( !vkCmdPipelineBarrier2 )
1458  vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) );
1459  if ( !vkCmdWriteTimestamp2 )
1461  vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) );
1462  if ( !vkQueueSubmit2 )
1464  vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) );
1465  vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) );
1466 
1467  //=== VK_KHR_timeline_semaphore ===
1468  vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) );
1471  vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) );
1472  if ( !vkWaitSemaphores )
1474  vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) );
1475  if ( !vkSignalSemaphore )
1477 
1478 # if defined( VK_ENABLE_BETA_EXTENSIONS )
1479  //=== VK_KHR_video_decode_queue ===
1480  vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) );
1481 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
1482 
1483 # if defined( VK_ENABLE_BETA_EXTENSIONS )
1484  //=== VK_KHR_video_encode_queue ===
1485  vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) );
1486 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
1487 
1488 # if defined( VK_ENABLE_BETA_EXTENSIONS )
1489  //=== VK_KHR_video_queue ===
1490  vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) );
1491  vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) );
1493  PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) );
1494  vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) );
1495  vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) );
1496  vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) );
1497  vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) );
1498  vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) );
1499  vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) );
1500  vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) );
1501 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
1502 
1503  //=== VK_NVX_binary_import ===
1504  vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) );
1505  vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) );
1506  vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) );
1507  vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) );
1508  vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) );
1509 
1510  //=== VK_NVX_image_view_handle ===
1511  vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
1512  vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
1513 
1514  //=== VK_NV_clip_space_w_scaling ===
1515  vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) );
1516 
1517  //=== VK_NV_copy_memory_indirect ===
1518  vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) );
1519  vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) );
1520 
1521  //=== VK_NV_device_diagnostic_checkpoints ===
1522  vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) );
1523  vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) );
1524 
1525  //=== VK_NV_device_generated_commands ===
1527  PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
1528  vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) );
1529  vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) );
1530  vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) );
1531  vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) );
1532  vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) );
1533 
1534  //=== VK_NV_external_memory_rdma ===
1535  vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) );
1536 
1537 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1538  //=== VK_NV_external_memory_win32 ===
1539  vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) );
1540 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1541 
1542  //=== VK_NV_fragment_shading_rate_enums ===
1543  vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) );
1544 
1545  //=== VK_NV_memory_decompression ===
1546  vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) );
1548  PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) );
1549 
1550  //=== VK_NV_mesh_shader ===
1551  vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) );
1552  vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) );
1553  vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) );
1554 
1555  //=== VK_NV_optical_flow ===
1556  vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) );
1557  vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) );
1558  vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) );
1559  vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) );
1560 
1561  //=== VK_NV_ray_tracing ===
1562  vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) );
1563  vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) );
1565  PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
1566  vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) );
1567  vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) );
1568  vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) );
1569  vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) );
1570  vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) );
1571  vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) );
1574  vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) );
1576  PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
1577  vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) );
1578 
1579  //=== VK_NV_scissor_exclusive ===
1580  vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
1581 
1582  //=== VK_NV_shading_rate_image ===
1583  vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) );
1585  PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) );
1586  vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) );
1587 
1588  //=== VK_QCOM_tile_properties ===
1589  vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
1591  PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
1592 
1593  //=== VK_VALVE_descriptor_set_host_mapping ===
1595  PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
1596  vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) );
1597  }
1598 
1599  public:
1600  //=== VK_VERSION_1_0 ===
1722 
1723  //=== VK_VERSION_1_1 ===
1740 
1741  //=== VK_VERSION_1_2 ===
1755 
1756  //=== VK_VERSION_1_3 ===
1793 
1794  //=== VK_AMD_buffer_marker ===
1796 
1797  //=== VK_AMD_display_native_hdr ===
1799 
1800  //=== VK_AMD_draw_indirect_count ===
1803 
1804  //=== VK_AMD_shader_info ===
1806 
1807 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1808  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
1811 # else
1814 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1815 
1816  //=== VK_EXT_buffer_device_address ===
1818 
1819  //=== VK_EXT_calibrated_timestamps ===
1821 
1822  //=== VK_EXT_color_write_enable ===
1824 
1825  //=== VK_EXT_conditional_rendering ===
1828 
1829  //=== VK_EXT_debug_marker ===
1835 
1836  //=== VK_EXT_debug_utils ===
1845 
1846  //=== VK_EXT_descriptor_buffer ===
1858 
1859  //=== VK_EXT_device_fault ===
1861 
1862  //=== VK_EXT_discard_rectangles ===
1864 
1865  //=== VK_EXT_display_control ===
1870 
1871  //=== VK_EXT_extended_dynamic_state ===
1884 
1885  //=== VK_EXT_extended_dynamic_state2 ===
1891 
1892  //=== VK_EXT_extended_dynamic_state3 ===
1924 
1925  //=== VK_EXT_external_memory_host ===
1927 
1928 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1929  //=== VK_EXT_full_screen_exclusive ===
1933 # else
1937 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1938 
1939  //=== VK_EXT_hdr_metadata ===
1941 
1942  //=== VK_EXT_host_query_reset ===
1944 
1945  //=== VK_EXT_image_compression_control ===
1947 
1948  //=== VK_EXT_image_drm_format_modifier ===
1950 
1951  //=== VK_EXT_line_rasterization ===
1953 
1954  //=== VK_EXT_mesh_shader ===
1958 
1959 # if defined( VK_USE_PLATFORM_METAL_EXT )
1960  //=== VK_EXT_metal_objects ===
1962 # else
1964 # endif /*VK_USE_PLATFORM_METAL_EXT*/
1965 
1966  //=== VK_EXT_multi_draw ===
1969 
1970  //=== VK_EXT_opacity_micromap ===
1985 
1986  //=== VK_EXT_pageable_device_local_memory ===
1988 
1989  //=== VK_EXT_pipeline_properties ===
1991 
1992  //=== VK_EXT_private_data ===
1997 
1998  //=== VK_EXT_sample_locations ===
2000 
2001  //=== VK_EXT_shader_module_identifier ===
2004 
2005  //=== VK_EXT_transform_feedback ===
2012 
2013  //=== VK_EXT_validation_cache ===
2018 
2019  //=== VK_EXT_vertex_input_dynamic_state ===
2021 
2022 # if defined( VK_USE_PLATFORM_FUCHSIA )
2023  //=== VK_FUCHSIA_buffer_collection ===
2029 # else
2035 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2036 
2037 # if defined( VK_USE_PLATFORM_FUCHSIA )
2038  //=== VK_FUCHSIA_external_memory ===
2041 # else
2044 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2045 
2046 # if defined( VK_USE_PLATFORM_FUCHSIA )
2047  //=== VK_FUCHSIA_external_semaphore ===
2050 # else
2053 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2054 
2055  //=== VK_GOOGLE_display_timing ===
2058 
2059  //=== VK_HUAWEI_invocation_mask ===
2061 
2062  //=== VK_HUAWEI_subpass_shading ===
2065 
2066  //=== VK_INTEL_performance_query ===
2076 
2077  //=== VK_KHR_acceleration_structure ===
2094 
2095  //=== VK_KHR_bind_memory2 ===
2098 
2099  //=== VK_KHR_buffer_device_address ===
2103 
2104  //=== VK_KHR_copy_commands2 ===
2111 
2112  //=== VK_KHR_create_renderpass2 ===
2117 
2118  //=== VK_KHR_deferred_host_operations ===
2124 
2125  //=== VK_KHR_descriptor_update_template ===
2130 
2131  //=== VK_KHR_device_group ===
2138 
2139  //=== VK_KHR_display_swapchain ===
2141 
2142  //=== VK_KHR_draw_indirect_count ===
2145 
2146  //=== VK_KHR_dynamic_rendering ===
2149 
2150  //=== VK_KHR_external_fence_fd ===
2153 
2154 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2155  //=== VK_KHR_external_fence_win32 ===
2158 # else
2161 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2162 
2163  //=== VK_KHR_external_memory_fd ===
2166 
2167 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2168  //=== VK_KHR_external_memory_win32 ===
2171 # else
2174 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2175 
2176  //=== VK_KHR_external_semaphore_fd ===
2179 
2180 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2181  //=== VK_KHR_external_semaphore_win32 ===
2184 # else
2187 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2188 
2189  //=== VK_KHR_fragment_shading_rate ===
2191 
2192  //=== VK_KHR_get_memory_requirements2 ===
2196 
2197  //=== VK_KHR_maintenance1 ===
2199 
2200  //=== VK_KHR_maintenance3 ===
2202 
2203  //=== VK_KHR_maintenance4 ===
2207 
2208  //=== VK_KHR_performance_query ===
2211 
2212  //=== VK_KHR_pipeline_executable_properties ===
2216 
2217  //=== VK_KHR_present_wait ===
2219 
2220  //=== VK_KHR_push_descriptor ===
2222 
2223  //=== VK_KHR_ray_tracing_maintenance1 ===
2225 
2226  //=== VK_KHR_ray_tracing_pipeline ===
2234 
2235  //=== VK_KHR_sampler_ycbcr_conversion ===
2238 
2239  //=== VK_KHR_shared_presentable_image ===
2241 
2242  //=== VK_KHR_swapchain ===
2248 
2249  //=== VK_KHR_synchronization2 ===
2258 
2259  //=== VK_KHR_timeline_semaphore ===
2263 
2264 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2265  //=== VK_KHR_video_decode_queue ===
2267 # else
2269 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2270 
2271 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2272  //=== VK_KHR_video_encode_queue ===
2274 # else
2276 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2277 
2278 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2279  //=== VK_KHR_video_queue ===
2290 # else
2301 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2302 
2303  //=== VK_NVX_binary_import ===
2309 
2310  //=== VK_NVX_image_view_handle ===
2313 
2314  //=== VK_NV_clip_space_w_scaling ===
2316 
2317  //=== VK_NV_copy_memory_indirect ===
2320 
2321  //=== VK_NV_device_diagnostic_checkpoints ===
2324 
2325  //=== VK_NV_device_generated_commands ===
2332 
2333  //=== VK_NV_external_memory_rdma ===
2335 
2336 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2337  //=== VK_NV_external_memory_win32 ===
2339 # else
2341 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2342 
2343  //=== VK_NV_fragment_shading_rate_enums ===
2345 
2346  //=== VK_NV_memory_decompression ===
2349 
2350  //=== VK_NV_mesh_shader ===
2354 
2355  //=== VK_NV_optical_flow ===
2360 
2361  //=== VK_NV_ray_tracing ===
2374 
2375  //=== VK_NV_scissor_exclusive ===
2377 
2378  //=== VK_NV_shading_rate_image ===
2382 
2383  //=== VK_QCOM_tile_properties ===
2386 
2387  //=== VK_VALVE_descriptor_set_host_mapping ===
2390  };
2391 
2392  //========================================
2393  //=== RAII HANDLE forward declarations ===
2394  //========================================
2395 
2396  //=== VK_VERSION_1_0 ===
2397  class Instance;
2398  class PhysicalDevice;
2399  class Device;
2400  class Queue;
2401  class DeviceMemory;
2402  class Fence;
2403  class Semaphore;
2404  class Event;
2405  class QueryPool;
2406  class Buffer;
2407  class BufferView;
2408  class Image;
2409  class ImageView;
2410  class ShaderModule;
2411  class PipelineCache;
2412  class Pipeline;
2413  class PipelineLayout;
2414  class Sampler;
2415  class DescriptorPool;
2416  class DescriptorSet;
2417  class DescriptorSetLayout;
2418  class Framebuffer;
2419  class RenderPass;
2420  class CommandPool;
2421  class CommandBuffer;
2422 
2423  //=== VK_VERSION_1_1 ===
2424  class SamplerYcbcrConversion;
2426 
2427  //=== VK_VERSION_1_3 ===
2428  class PrivateDataSlot;
2429 
2430  //=== VK_KHR_surface ===
2431  class SurfaceKHR;
2432 
2433  //=== VK_KHR_swapchain ===
2434  class SwapchainKHR;
2435 
2436  //=== VK_KHR_display ===
2437  class DisplayKHR;
2438  class DisplayModeKHR;
2439 
2440  //=== VK_EXT_debug_report ===
2441  class DebugReportCallbackEXT;
2442 
2443 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2444  //=== VK_KHR_video_queue ===
2445  class VideoSessionKHR;
2446  class VideoSessionParametersKHR;
2447 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2448 
2449  //=== VK_NVX_binary_import ===
2450  class CuModuleNVX;
2451  class CuFunctionNVX;
2452 
2453  //=== VK_EXT_debug_utils ===
2454  class DebugUtilsMessengerEXT;
2455 
2456  //=== VK_KHR_acceleration_structure ===
2458 
2459  //=== VK_EXT_validation_cache ===
2460  class ValidationCacheEXT;
2461 
2462  //=== VK_NV_ray_tracing ===
2464 
2465  //=== VK_INTEL_performance_query ===
2467 
2468  //=== VK_KHR_deferred_host_operations ===
2469  class DeferredOperationKHR;
2470 
2471  //=== VK_NV_device_generated_commands ===
2473 
2474 # if defined( VK_USE_PLATFORM_FUCHSIA )
2475  //=== VK_FUCHSIA_buffer_collection ===
2476  class BufferCollectionFUCHSIA;
2477 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2478 
2479  //=== VK_EXT_opacity_micromap ===
2480  class MicromapEXT;
2481 
2482  //=== VK_NV_optical_flow ===
2483  class OpticalFlowSessionNV;
2484 
2485  //====================
2486  //=== RAII HANDLES ===
2487  //====================
2488 
2489  class Context
2490  {
2491  public:
2492 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2493  Context()
2495  m_dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" ) ) )
2496 # else
2497  Context( PFN_vkGetInstanceProcAddr getInstanceProcAddr )
2498  : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher( getInstanceProcAddr ) )
2499 # endif
2500  {
2501  }
2502 
2503  ~Context() = default;
2504 
2505  Context( Context const & ) = delete;
2507 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2508  : m_dynamicLoader( std::move( rhs.m_dynamicLoader ) )
2509  , m_dispatcher( rhs.m_dispatcher.release() )
2510 # else
2511  : m_dispatcher( rhs.m_dispatcher.release() )
2512 # endif
2513  {
2514  }
2515  Context & operator=( Context const & ) = delete;
2517  {
2518  if ( this != &rhs )
2519  {
2520 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2521  m_dynamicLoader = std::move( rhs.m_dynamicLoader );
2522 # endif
2523  m_dispatcher.reset( rhs.m_dispatcher.release() );
2524  }
2525  return *this;
2526  }
2527 
2529  {
2530  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
2531  return &*m_dispatcher;
2532  }
2533 
2535  {
2536 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2537  std::swap( m_dynamicLoader, rhs.m_dynamicLoader );
2538 # endif
2539  m_dispatcher.swap( rhs.m_dispatcher );
2540  }
2541 
2542  //=== VK_VERSION_1_0 ===
2543 
2547 
2548  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties>
2550 
2551  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateInstanceLayerProperties() const;
2552 
2553  //=== VK_VERSION_1_1 ===
2554 
2556 
2557  private:
2558 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2559  VULKAN_HPP_NAMESPACE::DynamicLoader m_dynamicLoader;
2560 # endif
2561  std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher> m_dispatcher;
2562  };
2563 
2564  class Instance
2565  {
2566  public:
2567  using CType = VkInstance;
2568 
2572 
2573  public:
2575  VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo,
2577  : m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
2578  {
2580  static_cast<VULKAN_HPP_NAMESPACE::Result>( context.getDispatcher()->vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ),
2581  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
2582  reinterpret_cast<VkInstance *>( &m_instance ) ) );
2584  {
2585  throwResultException( result, "vkCreateInstance" );
2586  }
2588  static_cast<VkInstance>( m_instance ) ) );
2589  }
2590 
2592  VkInstance instance,
2594  : m_instance( instance ), m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
2595  {
2597  static_cast<VkInstance>( m_instance ) ) );
2598  }
2599 
2600  Instance( std::nullptr_t ) {}
2601 
2603  {
2604  clear();
2605  }
2606 
2607  Instance() = delete;
2608  Instance( Instance const & ) = delete;
2610  : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
2611  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
2612  , m_dispatcher( rhs.m_dispatcher.release() )
2613  {
2614  }
2615  Instance & operator=( Instance const & ) = delete;
2617  {
2618  if ( this != &rhs )
2619  {
2620  clear();
2621  m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
2622  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
2623  m_dispatcher.reset( rhs.m_dispatcher.release() );
2624  }
2625  return *this;
2626  }
2627 
2629  {
2630  return m_instance;
2631  }
2632 
2634  {
2635  if ( m_instance )
2636  {
2637  getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
2638  }
2639  m_instance = nullptr;
2640  m_allocator = nullptr;
2641  m_dispatcher = nullptr;
2642  }
2643 
2645  {
2646  m_allocator = nullptr;
2647  m_dispatcher = nullptr;
2648  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_instance, nullptr );
2649  }
2650 
2652  {
2653  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
2654  return &*m_dispatcher;
2655  }
2656 
2658  {
2659  std::swap( m_instance, rhs.m_instance );
2660  std::swap( m_allocator, rhs.m_allocator );
2661  std::swap( m_dispatcher, rhs.m_dispatcher );
2662  }
2663 
2664  //=== VK_VERSION_1_0 ===
2665 
2666  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> enumeratePhysicalDevices() const;
2667 
2669 
2670  //=== VK_VERSION_1_1 ===
2671 
2672  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroups() const;
2673 
2674  //=== VK_KHR_display ===
2675 
2677  createDisplayPlaneSurfaceKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo,
2679 
2680 # if defined( VK_USE_PLATFORM_XLIB_KHR )
2681  //=== VK_KHR_xlib_surface ===
2682 
2684  createXlibSurfaceKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo,
2686 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
2687 
2688 # if defined( VK_USE_PLATFORM_XCB_KHR )
2689  //=== VK_KHR_xcb_surface ===
2690 
2692  createXcbSurfaceKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo,
2694 # endif /*VK_USE_PLATFORM_XCB_KHR*/
2695 
2696 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
2697  //=== VK_KHR_wayland_surface ===
2698 
2700  createWaylandSurfaceKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo,
2702 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
2703 
2704 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
2705  //=== VK_KHR_android_surface ===
2706 
2708  createAndroidSurfaceKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo,
2710 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
2711 
2712 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2713  //=== VK_KHR_win32_surface ===
2714 
2716  createWin32SurfaceKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo,
2718 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2719 
2720  //=== VK_EXT_debug_report ===
2721 
2723  createDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo,
2725 
2726  void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags,
2728  uint64_t object,
2729  size_t location,
2730  int32_t messageCode,
2731  const std::string & layerPrefix,
2732  const std::string & message ) const VULKAN_HPP_NOEXCEPT;
2733 
2734 # if defined( VK_USE_PLATFORM_GGP )
2735  //=== VK_GGP_stream_descriptor_surface ===
2736 
2738  createStreamDescriptorSurfaceGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo,
2740 # endif /*VK_USE_PLATFORM_GGP*/
2741 
2742 # if defined( VK_USE_PLATFORM_VI_NN )
2743  //=== VK_NN_vi_surface ===
2744 
2746  createViSurfaceNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo,
2748 # endif /*VK_USE_PLATFORM_VI_NN*/
2749 
2750  //=== VK_KHR_device_group_creation ===
2751 
2752  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroupsKHR() const;
2753 
2754 # if defined( VK_USE_PLATFORM_IOS_MVK )
2755  //=== VK_MVK_ios_surface ===
2756 
2758  createIOSSurfaceMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo,
2760 # endif /*VK_USE_PLATFORM_IOS_MVK*/
2761 
2762 # if defined( VK_USE_PLATFORM_MACOS_MVK )
2763  //=== VK_MVK_macos_surface ===
2764 
2766  createMacOSSurfaceMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo,
2768 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
2769 
2770  //=== VK_EXT_debug_utils ===
2771 
2773  createDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo,
2775 
2776  void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
2779 
2780 # if defined( VK_USE_PLATFORM_FUCHSIA )
2781  //=== VK_FUCHSIA_imagepipe_surface ===
2782 
2784  createImagePipeSurfaceFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo,
2786 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2787 
2788 # if defined( VK_USE_PLATFORM_METAL_EXT )
2789  //=== VK_EXT_metal_surface ===
2790 
2792  createMetalSurfaceEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo,
2794 # endif /*VK_USE_PLATFORM_METAL_EXT*/
2795 
2796  //=== VK_EXT_headless_surface ===
2797 
2799  createHeadlessSurfaceEXT( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo,
2801 
2802 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
2803  //=== VK_EXT_directfb_surface ===
2804 
2806  createDirectFBSurfaceEXT( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo,
2808 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
2809 
2810 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
2811  //=== VK_QNX_screen_surface ===
2812 
2814  createScreenSurfaceQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo,
2816 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
2817 
2818  private:
2819  VULKAN_HPP_NAMESPACE::Instance m_instance = {};
2820  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
2821  std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher> m_dispatcher;
2822  };
2823 
2825  {
2826  public:
2827  using CType = VkPhysicalDevice;
2828 
2832 
2833  public:
2834  PhysicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VkPhysicalDevice physicalDevice )
2835  : m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() )
2836  {
2837  }
2838 
2839  PhysicalDevice( std::nullptr_t ) {}
2840 
2842  {
2843  clear();
2844  }
2845 
2846  PhysicalDevice() = delete;
2847  PhysicalDevice( PhysicalDevice const & rhs ) : m_physicalDevice( rhs.m_physicalDevice ), m_dispatcher( rhs.m_dispatcher ) {}
2849  : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
2851  {
2852  }
2854  {
2855  m_physicalDevice = rhs.m_physicalDevice;
2856  m_dispatcher = rhs.m_dispatcher;
2857  return *this;
2858  }
2860  {
2861  if ( this != &rhs )
2862  {
2863  m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
2864  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
2865  }
2866  return *this;
2867  }
2868 
2870  {
2871  return m_physicalDevice;
2872  }
2873 
2875  {
2876  m_physicalDevice = nullptr;
2877  m_dispatcher = nullptr;
2878  }
2879 
2881  {
2882  m_dispatcher = nullptr;
2883  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_physicalDevice, nullptr );
2884  }
2885 
2887  {
2888  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
2889  return m_dispatcher;
2890  }
2891 
2893  {
2894  std::swap( m_physicalDevice, rhs.m_physicalDevice );
2895  std::swap( m_dispatcher, rhs.m_dispatcher );
2896  }
2897 
2898  //=== VK_VERSION_1_0 ===
2899 
2901 
2903 
2905  getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
2910 
2911  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties() const VULKAN_HPP_NOEXCEPT;
2912 
2913  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> getQueueFamilyProperties() const;
2914 
2915  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties() const VULKAN_HPP_NOEXCEPT;
2916 
2918  createDevice( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo,
2919  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
2920 
2922  enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
2923 
2924  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateDeviceLayerProperties() const;
2925 
2927  getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
2931  VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const;
2932 
2933  //=== VK_VERSION_1_1 ===
2934 
2935  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2() const VULKAN_HPP_NOEXCEPT;
2936 
2937  template <typename X, typename Y, typename... Z>
2938  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2() const VULKAN_HPP_NOEXCEPT;
2939 
2940  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2() const VULKAN_HPP_NOEXCEPT;
2941 
2942  template <typename X, typename Y, typename... Z>
2943  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2() const VULKAN_HPP_NOEXCEPT;
2944 
2945  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
2946 
2947  template <typename X, typename Y, typename... Z>
2948  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
2949 
2951  getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
2952 
2953  template <typename X, typename Y, typename... Z>
2955  getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
2956 
2957  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2() const;
2958 
2959  template <typename StructureChain>
2960  VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2() const;
2961 
2962  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2() const VULKAN_HPP_NOEXCEPT;
2963 
2964  template <typename X, typename Y, typename... Z>
2965  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2() const VULKAN_HPP_NOEXCEPT;
2966 
2968  getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const;
2969 
2971  getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT;
2972 
2974  getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT;
2975 
2977  getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT;
2978 
2979  //=== VK_VERSION_1_3 ===
2980 
2981  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> getToolProperties() const;
2982 
2983  //=== VK_KHR_surface ===
2984 
2985  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
2986 
2988 
2990  getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
2991 
2993  getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
2994 
2995  //=== VK_KHR_swapchain ===
2996 
2997  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Rect2D> getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
2998 
2999  //=== VK_KHR_display ===
3000 
3001  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> getDisplayPropertiesKHR() const;
3002 
3003  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> getDisplayPlanePropertiesKHR() const;
3004 
3005  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const;
3006 
3007 # if defined( VK_USE_PLATFORM_XLIB_KHR )
3008  //=== VK_KHR_xlib_surface ===
3009 
3011  getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT;
3012 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
3013 
3014 # if defined( VK_USE_PLATFORM_XCB_KHR )
3015  //=== VK_KHR_xcb_surface ===
3016 
3018  getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT;
3019 # endif /*VK_USE_PLATFORM_XCB_KHR*/
3020 
3021 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
3022  //=== VK_KHR_wayland_surface ===
3023 
3024  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
3025  struct wl_display & display ) const VULKAN_HPP_NOEXCEPT;
3026 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
3027 
3028 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3029  //=== VK_KHR_win32_surface ===
3030 
3031  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT;
3032 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3033 
3034 # if defined( VK_ENABLE_BETA_EXTENSIONS )
3035  //=== VK_KHR_video_queue ===
3036 
3037  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR
3038  getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const;
3039 
3040  template <typename X, typename Y, typename... Z>
3041  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const;
3042 
3043  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
3044  getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const;
3045 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
3046 
3047  //=== VK_NV_external_memory_capabilities ===
3048 
3055  VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
3056 
3057  //=== VK_KHR_get_physical_device_properties2 ===
3058 
3059  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR() const VULKAN_HPP_NOEXCEPT;
3060 
3061  template <typename X, typename Y, typename... Z>
3062  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFeatures2KHR() const VULKAN_HPP_NOEXCEPT;
3063 
3064  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2KHR() const VULKAN_HPP_NOEXCEPT;
3065 
3066  template <typename X, typename Y, typename... Z>
3067  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getProperties2KHR() const VULKAN_HPP_NOEXCEPT;
3068 
3069  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
3070 
3071  template <typename X, typename Y, typename... Z>
3072  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
3073 
3075  getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
3076 
3077  template <typename X, typename Y, typename... Z>
3079  getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
3080 
3081  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2KHR() const;
3082 
3083  template <typename StructureChain>
3084  VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2KHR() const;
3085 
3086  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT;
3087 
3088  template <typename X, typename Y, typename... Z>
3089  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT;
3090 
3092  getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const;
3093 
3094  //=== VK_KHR_external_memory_capabilities ===
3095 
3097  getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT;
3098 
3099  //=== VK_KHR_external_semaphore_capabilities ===
3100 
3102  getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT;
3103 
3104 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
3105  //=== VK_EXT_acquire_xlib_display ===
3106 
3107  void acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const;
3108 
3109  VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const;
3110 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
3111 
3112  //=== VK_EXT_display_surface_counter ===
3113 
3115 
3116  //=== VK_KHR_external_fence_capabilities ===
3117 
3119  getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT;
3120 
3121  //=== VK_KHR_performance_query ===
3122 
3124  std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>>
3125  enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const;
3126 
3127  VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
3128  const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT;
3129 
3130  //=== VK_KHR_get_surface_capabilities2 ===
3131 
3133  getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3134 
3135  template <typename X, typename Y, typename... Z>
3137  getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3138 
3139  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
3140  getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3141 
3142  template <typename StructureChain>
3143  VULKAN_HPP_NODISCARD std::vector<StructureChain> getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3144 
3145  //=== VK_KHR_get_display_properties2 ===
3146 
3147  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> getDisplayProperties2KHR() const;
3148 
3149  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> getDisplayPlaneProperties2KHR() const;
3150 
3152  getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const;
3153 
3154  //=== VK_EXT_sample_locations ===
3155 
3157  getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT;
3158 
3159  //=== VK_EXT_calibrated_timestamps ===
3160 
3161  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> getCalibrateableTimeDomainsEXT() const;
3162 
3163  //=== VK_KHR_fragment_shading_rate ===
3164 
3165  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> getFragmentShadingRatesKHR() const;
3166 
3167  //=== VK_EXT_tooling_info ===
3168 
3169  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> getToolPropertiesEXT() const;
3170 
3171  //=== VK_NV_cooperative_matrix ===
3172 
3173  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> getCooperativeMatrixPropertiesNV() const;
3174 
3175  //=== VK_NV_coverage_reduction_mode ===
3176 
3177  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> getSupportedFramebufferMixedSamplesCombinationsNV() const;
3178 
3179 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3180  //=== VK_EXT_full_screen_exclusive ===
3181 
3182  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
3183  getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3184 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3185 
3186  //=== VK_EXT_acquire_drm_display ===
3187 
3188  void acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const;
3189 
3190  VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const;
3191 
3192 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3193  //=== VK_NV_acquire_winrt_display ===
3194 
3195  VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::DisplayKHR getWinrtDisplayNV( uint32_t deviceRelativeId ) const;
3196 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3197 
3198 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
3199  //=== VK_EXT_directfb_surface ===
3200 
3201  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
3202  IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT;
3203 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
3204 
3205 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
3206  //=== VK_QNX_screen_surface ===
3207 
3208  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
3209  struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT;
3210 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
3211 
3212  //=== VK_NV_optical_flow ===
3213 
3214  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>
3215  getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const;
3216 
3217  private:
3218  VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {};
3220  };
3221 
3222  class PhysicalDevices : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice>
3223  {
3224  public:
3226  {
3228  std::vector<VkPhysicalDevice> physicalDevices;
3229  uint32_t physicalDeviceCount;
3231  do
3232  {
3233  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
3234  dispatcher->vkEnumeratePhysicalDevices( static_cast<VkInstance>( *instance ), &physicalDeviceCount, nullptr ) );
3235  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceCount )
3236  {
3237  physicalDevices.resize( physicalDeviceCount );
3238  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
3239  dispatcher->vkEnumeratePhysicalDevices( static_cast<VkInstance>( *instance ), &physicalDeviceCount, physicalDevices.data() ) );
3240  }
3241  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
3243  {
3244  VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
3245  this->reserve( physicalDeviceCount );
3246  for ( auto const & physicalDevice : physicalDevices )
3247  {
3248  this->emplace_back( instance, physicalDevice );
3249  }
3250  }
3251  else
3252  {
3253  throwResultException( result, "vkEnumeratePhysicalDevices" );
3254  }
3255  }
3256 
3257  PhysicalDevices( std::nullptr_t ) {}
3258 
3259  PhysicalDevices() = delete;
3260  PhysicalDevices( PhysicalDevices const & ) = delete;
3261  PhysicalDevices( PhysicalDevices && rhs ) = default;
3262  PhysicalDevices & operator=( PhysicalDevices const & ) = delete;
3263  PhysicalDevices & operator=( PhysicalDevices && rhs ) = default;
3264  };
3265 
3266  class Device
3267  {
3268  public:
3269  using CType = VkDevice;
3270 
3274 
3275  public:
3277  VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo,
3279  : m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
3280  {
3282  physicalDevice.getDispatcher()->vkCreateDevice( static_cast<VkPhysicalDevice>( *physicalDevice ),
3283  reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
3284  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
3285  reinterpret_cast<VkDevice *>( &m_device ) ) );
3287  {
3288  throwResultException( result, "vkCreateDevice" );
3289  }
3291  static_cast<VkDevice>( m_device ) ) );
3292  }
3293 
3295  VkDevice device,
3297  : m_device( device ), m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
3298  {
3300  static_cast<VkDevice>( m_device ) ) );
3301  }
3302 
3303  Device( std::nullptr_t ) {}
3304 
3306  {
3307  clear();
3308  }
3309 
3310  Device() = delete;
3311  Device( Device const & ) = delete;
3312  Device( Device && rhs ) VULKAN_HPP_NOEXCEPT
3313  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
3314  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
3315  , m_dispatcher( rhs.m_dispatcher.release() )
3316  {
3317  }
3318  Device & operator=( Device const & ) = delete;
3319  Device & operator =( Device && rhs ) VULKAN_HPP_NOEXCEPT
3320  {
3321  if ( this != &rhs )
3322  {
3323  clear();
3324  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
3325  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
3326  m_dispatcher.reset( rhs.m_dispatcher.release() );
3327  }
3328  return *this;
3329  }
3330 
3331  VULKAN_HPP_NAMESPACE::Device const & operator*() const VULKAN_HPP_NOEXCEPT
3332  {
3333  return m_device;
3334  }
3335 
3336  void clear() VULKAN_HPP_NOEXCEPT
3337  {
3338  if ( m_device )
3339  {
3340  getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
3341  }
3342  m_device = nullptr;
3343  m_allocator = nullptr;
3344  m_dispatcher = nullptr;
3345  }
3346 
3348  {
3349  m_allocator = nullptr;
3350  m_dispatcher = nullptr;
3352  }
3353 
3355  {
3356  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
3357  return &*m_dispatcher;
3358  }
3359 
3361  {
3362  std::swap( m_device, rhs.m_device );
3363  std::swap( m_allocator, rhs.m_allocator );
3364  std::swap( m_dispatcher, rhs.m_dispatcher );
3365  }
3366 
3367  //=== VK_VERSION_1_0 ===
3368 
3370 
3371  VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const;
3372 
3373  void waitIdle() const;
3374 
3376  allocateMemory( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo,
3378 
3379  void flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const;
3380 
3381  void invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const;
3382 
3384  createFence( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo,
3386 
3387  void resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const;
3388 
3391  uint64_t timeout ) const;
3392 
3394  createSemaphore( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo,
3396 
3398  createEvent( VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo,
3400 
3402  createQueryPool( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo,
3404 
3406  createBuffer( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo,
3408 
3410  createBufferView( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo,
3412 
3414  createImage( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo,
3416 
3418  createImageView( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo,
3420 
3422  createShaderModule( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo,
3424 
3426  createPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo,
3428 
3429  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline>
3433 
3438 
3439  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline>
3443 
3448 
3450  createPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo,
3452 
3456 
3458  createDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo,
3460 
3462  createDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo,
3464 
3465  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>
3466  allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const;
3467 
3468  void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
3471 
3473  createFramebuffer( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo,
3475 
3477  createRenderPass( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo,
3479 
3481  createCommandPool( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo,
3483 
3484  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>
3485  allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const;
3486 
3487  //=== VK_VERSION_1_1 ===
3488 
3489  void bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const;
3490 
3491  void bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const;
3492 
3494  getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT;
3495 
3497  getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3498 
3499  template <typename X, typename Y, typename... Z>
3501  getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3502 
3504  getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3505 
3506  template <typename X, typename Y, typename... Z>
3508  getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3509 
3510  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
3511  getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const;
3512 
3514 
3516  createSamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,
3518 
3520  createDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,
3522 
3524  getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
3525 
3526  template <typename X, typename Y, typename... Z>
3528  getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
3529 
3530  //=== VK_VERSION_1_2 ===
3531 
3533  createRenderPass2( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,
3535 
3536  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const;
3537 
3538  void signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const;
3539 
3541  getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3542 
3543  VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3544 
3545  VULKAN_HPP_NODISCARD uint64_t
3546  getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3547 
3548  //=== VK_VERSION_1_3 ===
3549 
3551  createPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,
3553 
3554  void setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
3555  uint64_t objectHandle,
3556  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
3557  uint64_t data ) const;
3558 
3559  VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
3560  uint64_t objectHandle,
3562 
3564  getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
3565 
3566  template <typename X, typename Y, typename... Z>
3568  getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
3569 
3571  getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
3572 
3573  template <typename X, typename Y, typename... Z>
3575  getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
3576 
3577  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
3578  getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const;
3579 
3580  //=== VK_KHR_swapchain ===
3581 
3583  createSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,
3585 
3587 
3589  getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
3590 
3591  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
3592  acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo ) const;
3593 
3594  //=== VK_KHR_display_swapchain ===
3595 
3596  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>
3597  createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
3599 
3601  createSharedSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,
3603 
3604  //=== VK_EXT_debug_marker ===
3605 
3606  void debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo ) const;
3607 
3608  void debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo ) const;
3609 
3610 # if defined( VK_ENABLE_BETA_EXTENSIONS )
3611  //=== VK_KHR_video_queue ===
3612 
3613  VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR
3614  createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,
3616 
3617  VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR
3618  createVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo,
3620 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
3621 
3622  //=== VK_NVX_binary_import ===
3623 
3625  createCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo,
3627 
3629  createCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo,
3631 
3632  //=== VK_NVX_image_view_handle ===
3633 
3634  VULKAN_HPP_NODISCARD uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT;
3635 
3636  //=== VK_KHR_device_group ===
3637 
3639  getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT;
3640 
3641 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3642  //=== VK_KHR_external_memory_win32 ===
3643 
3644  VULKAN_HPP_NODISCARD HANDLE getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
3645 
3646  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR
3647  getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const;
3648 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3649 
3650  //=== VK_KHR_external_memory_fd ===
3651 
3652  VULKAN_HPP_NODISCARD int getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo ) const;
3653 
3655  getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd ) const;
3656 
3657 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3658  //=== VK_KHR_external_semaphore_win32 ===
3659 
3660  void importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const;
3661 
3662  VULKAN_HPP_NODISCARD HANDLE getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
3663 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3664 
3665  //=== VK_KHR_external_semaphore_fd ===
3666 
3667  void importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const;
3668 
3669  VULKAN_HPP_NODISCARD int getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo ) const;
3670 
3671  //=== VK_KHR_descriptor_update_template ===
3672 
3674  createDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,
3676 
3677  void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
3680 
3681  //=== VK_EXT_display_control ===
3682 
3683  void displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo ) const;
3684 
3686  registerEventEXT( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo,
3688 
3690  registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,
3691  VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo,
3693 
3694  //=== VK_EXT_hdr_metadata ===
3695 
3696  void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,
3698 
3699  //=== VK_KHR_create_renderpass2 ===
3700 
3702  createRenderPass2KHR( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,
3704 
3705 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3706  //=== VK_KHR_external_fence_win32 ===
3707 
3708  void importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const;
3709 
3710  VULKAN_HPP_NODISCARD HANDLE getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
3711 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3712 
3713  //=== VK_KHR_external_fence_fd ===
3714 
3715  void importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo ) const;
3716 
3717  VULKAN_HPP_NODISCARD int getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo ) const;
3718 
3719  //=== VK_KHR_performance_query ===
3720 
3721  void acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info ) const;
3722 
3723  void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT;
3724 
3725  //=== VK_EXT_debug_utils ===
3726 
3727  void setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo ) const;
3728 
3729  void setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo ) const;
3730 
3731 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
3732  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
3733 
3734  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID
3735  getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const;
3736 
3737  template <typename X, typename Y, typename... Z>
3738  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const;
3739 
3740  VULKAN_HPP_NODISCARD struct AHardwareBuffer *
3741  getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info ) const;
3742 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
3743 
3744  //=== VK_KHR_get_memory_requirements2 ===
3745 
3747  getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3748 
3749  template <typename X, typename Y, typename... Z>
3751  getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3752 
3754  getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3755 
3756  template <typename X, typename Y, typename... Z>
3758  getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3759 
3760  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
3761  getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const;
3762 
3763  //=== VK_KHR_acceleration_structure ===
3764 
3766  createAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo,
3768 
3769  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR(
3773 
3775  copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
3777 
3779  copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
3781 
3783  copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
3785 
3786  template <typename DataType>
3787  VULKAN_HPP_NODISCARD std::vector<DataType> writeAccelerationStructuresPropertiesKHR(
3790  size_t dataSize,
3791  size_t stride ) const;
3792 
3793  template <typename DataType>
3794  VULKAN_HPP_NODISCARD DataType writeAccelerationStructuresPropertyKHR(
3797  size_t stride ) const;
3798 
3800  getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
3801 
3803  getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT;
3804 
3809 
3810  //=== VK_KHR_sampler_ycbcr_conversion ===
3811 
3813  createSamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,
3815 
3816  void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
3819 
3820  //=== VK_KHR_bind_memory2 ===
3821 
3822  void bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const;
3823 
3824  void bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const;
3825 
3826  //=== VK_EXT_validation_cache ===
3827 
3829  createValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo,
3831 
3832  //=== VK_NV_ray_tracing ===
3833 
3835  createAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo,
3837 
3838  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
3840 
3841  template <typename X, typename Y, typename... Z>
3842  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
3844 
3845  void bindAccelerationStructureMemoryNV(
3847 
3848  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline>
3852 
3857 
3858  //=== VK_KHR_maintenance3 ===
3859 
3861  getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
3862 
3863  template <typename X, typename Y, typename... Z>
3865  getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
3866 
3867  //=== VK_EXT_external_memory_host ===
3868 
3870  getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const;
3871 
3872  //=== VK_EXT_calibrated_timestamps ===
3873 
3874  VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t>
3875  getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos ) const;
3876 
3877  VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t>
3878  getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo ) const;
3879 
3880  //=== VK_KHR_timeline_semaphore ===
3881 
3882  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const;
3883 
3884  void signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const;
3885 
3886  //=== VK_INTEL_performance_query ===
3887 
3888  void initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo ) const;
3889 
3890  void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT;
3891 
3893  acquirePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const;
3894 
3896  getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const;
3897 
3898  //=== VK_EXT_buffer_device_address ===
3899 
3901  getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3902 
3903 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3904  //=== VK_EXT_full_screen_exclusive ===
3905 
3907  getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3908 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3909 
3910  //=== VK_KHR_buffer_device_address ===
3911 
3913  getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3914 
3915  VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3916 
3917  VULKAN_HPP_NODISCARD uint64_t
3918  getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3919 
3920  //=== VK_KHR_deferred_host_operations ===
3921 
3923  createDeferredOperationKHR( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
3924 
3925  //=== VK_KHR_pipeline_executable_properties ===
3926 
3927  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
3928  getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo ) const;
3929 
3930  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>
3931  getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const;
3932 
3933  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
3934  getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const;
3935 
3936  //=== VK_NV_device_generated_commands ===
3937 
3939  getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
3940 
3941  template <typename X, typename Y, typename... Z>
3943  getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
3944 
3946  createIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo,
3948 
3949  //=== VK_EXT_private_data ===
3950 
3952  createPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,
3954 
3955  void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
3958 
3959  void setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
3960  uint64_t objectHandle,
3961  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
3962  uint64_t data ) const;
3963 
3964  VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
3965  uint64_t objectHandle,
3967 
3968 # if defined( VK_USE_PLATFORM_METAL_EXT )
3969  //=== VK_EXT_metal_objects ===
3970 
3971  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT;
3972 
3973  template <typename X, typename Y, typename... Z>
3974  VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT;
3975 # endif /*VK_USE_PLATFORM_METAL_EXT*/
3976 
3977  //=== VK_EXT_descriptor_buffer ===
3978 
3979  template <typename DescriptorType>
3981 
3982  template <typename DataType>
3983  VULKAN_HPP_NODISCARD DataType getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info ) const;
3984 
3985  template <typename DataType>
3986  VULKAN_HPP_NODISCARD DataType getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info ) const;
3987 
3988  template <typename DataType>
3990  getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info ) const;
3991 
3992  template <typename DataType>
3993  VULKAN_HPP_NODISCARD DataType getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info ) const;
3994 
3995  template <typename DataType>
3997  getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const;
3998 
3999  //=== VK_EXT_device_fault ===
4000 
4002  std::pair<VULKAN_HPP_NAMESPACE::Result, std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>
4003  getFaultInfoEXT() const;
4004 
4005  //=== VK_KHR_ray_tracing_pipeline ===
4006 
4007  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createRayTracingPipelinesKHR(
4012 
4013  VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Pipeline createRayTracingPipelineKHR(
4018 
4019 # if defined( VK_USE_PLATFORM_FUCHSIA )
4020  //=== VK_FUCHSIA_external_memory ===
4021 
4022  VULKAN_HPP_NODISCARD zx_handle_t getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const;
4023 
4024  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA
4025  getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const;
4026 # endif /*VK_USE_PLATFORM_FUCHSIA*/
4027 
4028 # if defined( VK_USE_PLATFORM_FUCHSIA )
4029  //=== VK_FUCHSIA_external_semaphore ===
4030 
4031  void importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const;
4032 
4033  VULKAN_HPP_NODISCARD zx_handle_t
4034  getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const;
4035 # endif /*VK_USE_PLATFORM_FUCHSIA*/
4036 
4037 # if defined( VK_USE_PLATFORM_FUCHSIA )
4038  //=== VK_FUCHSIA_buffer_collection ===
4039 
4040  VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA
4041  createBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo,
4043 # endif /*VK_USE_PLATFORM_FUCHSIA*/
4044 
4045  //=== VK_NV_external_memory_rdma ===
4046 
4048  getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const;
4049 
4050  //=== VK_EXT_pipeline_properties ===
4051 
4052  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BaseOutStructure getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo ) const;
4053 
4054  //=== VK_EXT_opacity_micromap ===
4055 
4057  createMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo,
4059 
4061  buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
4063 
4065  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const;
4066 
4069 
4072 
4073  template <typename DataType>
4074  VULKAN_HPP_NODISCARD std::vector<DataType>
4075  writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
4077  size_t dataSize,
4078  size_t stride ) const;
4079 
4080  template <typename DataType>
4083  size_t stride ) const;
4084 
4086  getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT;
4087 
4089  getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
4091 
4092  //=== VK_KHR_maintenance4 ===
4093 
4095  getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
4096 
4097  template <typename X, typename Y, typename... Z>
4099  getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
4100 
4102  getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
4103 
4104  template <typename X, typename Y, typename... Z>
4106  getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
4107 
4108  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
4109  getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const;
4110 
4111  //=== VK_VALVE_descriptor_set_host_mapping ===
4112 
4115 
4116  //=== VK_EXT_shader_module_identifier ===
4117 
4119  getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
4120 
4121  //=== VK_NV_optical_flow ===
4122 
4124  createOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo,
4126 
4127  //=== VK_QCOM_tile_properties ===
4128 
4130  getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT;
4131 
4132  private:
4133  VULKAN_HPP_NAMESPACE::Device m_device = {};
4134  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4135  std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher> m_dispatcher;
4136  };
4137 
4139  {
4140  public:
4141  using CType = VkAccelerationStructureKHR;
4142 
4146 
4147  public:
4151  : m_device( *device )
4152  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4153  , m_dispatcher( device.getDispatcher() )
4154  {
4156  device.getDispatcher()->vkCreateAccelerationStructureKHR( static_cast<VkDevice>( *device ),
4157  reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
4158  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4159  reinterpret_cast<VkAccelerationStructureKHR *>( &m_accelerationStructure ) ) );
4161  {
4162  throwResultException( result, "vkCreateAccelerationStructureKHR" );
4163  }
4164  }
4165 
4167  VkAccelerationStructureKHR accelerationStructure,
4169  : m_device( *device )
4170  , m_accelerationStructure( accelerationStructure )
4171  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4172  , m_dispatcher( device.getDispatcher() )
4173  {
4174  }
4175 
4176  AccelerationStructureKHR( std::nullptr_t ) {}
4177 
4179  {
4180  clear();
4181  }
4182 
4183  AccelerationStructureKHR() = delete;
4186  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4187  , m_accelerationStructure( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) )
4188  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4190  {
4191  }
4194  {
4195  if ( this != &rhs )
4196  {
4197  clear();
4198  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
4199  m_accelerationStructure = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} );
4200  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
4201  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
4202  }
4203  return *this;
4204  }
4205 
4206  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const VULKAN_HPP_NOEXCEPT
4207  {
4208  return m_accelerationStructure;
4209  }
4210 
4211  void clear() VULKAN_HPP_NOEXCEPT
4212  {
4213  if ( m_accelerationStructure )
4214  {
4215  getDispatcher()->vkDestroyAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
4216  static_cast<VkAccelerationStructureKHR>( m_accelerationStructure ),
4217  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4218  }
4219  m_device = nullptr;
4220  m_accelerationStructure = nullptr;
4221  m_allocator = nullptr;
4222  m_dispatcher = nullptr;
4223  }
4224 
4226  {
4227  m_device = nullptr;
4228  m_allocator = nullptr;
4229  m_dispatcher = nullptr;
4230  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_accelerationStructure, nullptr );
4231  }
4232 
4234  {
4235  return m_device;
4236  }
4237 
4239  {
4240  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4241  return m_dispatcher;
4242  }
4243 
4245  {
4246  std::swap( m_device, rhs.m_device );
4247  std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
4248  std::swap( m_allocator, rhs.m_allocator );
4249  std::swap( m_dispatcher, rhs.m_dispatcher );
4250  }
4251 
4252  private:
4253  VULKAN_HPP_NAMESPACE::Device m_device = {};
4254  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructure = {};
4255  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4257  };
4258 
4260  {
4261  public:
4262  using CType = VkAccelerationStructureNV;
4263 
4267 
4268  public:
4272  : m_device( *device )
4273  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4274  , m_dispatcher( device.getDispatcher() )
4275  {
4277  device.getDispatcher()->vkCreateAccelerationStructureNV( static_cast<VkDevice>( *device ),
4278  reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
4279  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4280  reinterpret_cast<VkAccelerationStructureNV *>( &m_accelerationStructure ) ) );
4282  {
4283  throwResultException( result, "vkCreateAccelerationStructureNV" );
4284  }
4285  }
4286 
4288  VkAccelerationStructureNV accelerationStructure,
4290  : m_device( *device )
4291  , m_accelerationStructure( accelerationStructure )
4292  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4293  , m_dispatcher( device.getDispatcher() )
4294  {
4295  }
4296 
4297  AccelerationStructureNV( std::nullptr_t ) {}
4298 
4300  {
4301  clear();
4302  }
4303 
4304  AccelerationStructureNV() = delete;
4306  AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT
4307  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4308  , m_accelerationStructure( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) )
4309  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4311  {
4312  }
4315  {
4316  if ( this != &rhs )
4317  {
4318  clear();
4319  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
4320  m_accelerationStructure = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} );
4321  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
4322  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
4323  }
4324  return *this;
4325  }
4326 
4328  {
4329  return m_accelerationStructure;
4330  }
4331 
4333  {
4334  if ( m_accelerationStructure )
4335  {
4336  getDispatcher()->vkDestroyAccelerationStructureNV( static_cast<VkDevice>( m_device ),
4337  static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
4338  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4339  }
4340  m_device = nullptr;
4341  m_accelerationStructure = nullptr;
4342  m_allocator = nullptr;
4343  m_dispatcher = nullptr;
4344  }
4345 
4347  {
4348  m_device = nullptr;
4349  m_allocator = nullptr;
4350  m_dispatcher = nullptr;
4351  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_accelerationStructure, nullptr );
4352  }
4353 
4355  {
4356  return m_device;
4357  }
4358 
4360  {
4361  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4362  return m_dispatcher;
4363  }
4364 
4366  {
4367  std::swap( m_device, rhs.m_device );
4368  std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
4369  std::swap( m_allocator, rhs.m_allocator );
4370  std::swap( m_dispatcher, rhs.m_dispatcher );
4371  }
4372 
4373  //=== VK_NV_ray_tracing ===
4374 
4375  template <typename DataType>
4376  VULKAN_HPP_NODISCARD std::vector<DataType> getHandle( size_t dataSize ) const;
4377 
4378  template <typename DataType>
4379  VULKAN_HPP_NODISCARD DataType getHandle() const;
4380 
4381  private:
4382  VULKAN_HPP_NAMESPACE::Device m_device = {};
4383  VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructure = {};
4384  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4386  };
4387 
4388  class Buffer
4389  {
4390  public:
4391  using CType = VkBuffer;
4392 
4396 
4397  public:
4399  VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo,
4401  : m_device( *device )
4402  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4403  , m_dispatcher( device.getDispatcher() )
4404  {
4406  static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateBuffer( static_cast<VkDevice>( *device ),
4407  reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
4408  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4409  reinterpret_cast<VkBuffer *>( &m_buffer ) ) );
4411  {
4412  throwResultException( result, "vkCreateBuffer" );
4413  }
4414  }
4415 
4417  VkBuffer buffer,
4419  : m_device( *device )
4420  , m_buffer( buffer )
4421  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4422  , m_dispatcher( device.getDispatcher() )
4423  {
4424  }
4425 
4426  Buffer( std::nullptr_t ) {}
4427 
4429  {
4430  clear();
4431  }
4432 
4433  Buffer() = delete;
4434  Buffer( Buffer const & ) = delete;
4436  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4437  , m_buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} ) )
4438  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4440  {
4441  }
4442  Buffer & operator=( Buffer const & ) = delete;
4444  {
4445  if ( this != &rhs )
4446  {
4447  clear();
4448  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
4449  m_buffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} );
4450  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
4451  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
4452  }
4453  return *this;
4454  }
4455 
4457  {
4458  return m_buffer;
4459  }
4460 
4462  {
4463  if ( m_buffer )
4464  {
4465  getDispatcher()->vkDestroyBuffer(
4466  static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( m_buffer ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4467  }
4468  m_device = nullptr;
4469  m_buffer = nullptr;
4470  m_allocator = nullptr;
4471  m_dispatcher = nullptr;
4472  }
4473 
4475  {
4476  m_device = nullptr;
4477  m_allocator = nullptr;
4478  m_dispatcher = nullptr;
4480  }
4481 
4483  {
4484  return m_device;
4485  }
4486 
4488  {
4489  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4490  return m_dispatcher;
4491  }
4492 
4494  {
4495  std::swap( m_device, rhs.m_device );
4496  std::swap( m_buffer, rhs.m_buffer );
4497  std::swap( m_allocator, rhs.m_allocator );
4498  std::swap( m_dispatcher, rhs.m_dispatcher );
4499  }
4500 
4501  //=== VK_VERSION_1_0 ===
4502 
4503  void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
4504 
4506 
4507  private:
4508  VULKAN_HPP_NAMESPACE::Device m_device = {};
4509  VULKAN_HPP_NAMESPACE::Buffer m_buffer = {};
4510  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4512  };
4513 
4514 # if defined( VK_USE_PLATFORM_FUCHSIA )
4515  class BufferCollectionFUCHSIA
4516  {
4517  public:
4518  using CType = VkBufferCollectionFUCHSIA;
4519 
4520  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
4522  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
4523 
4524  public:
4525  BufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4526  VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo,
4528  : m_device( *device )
4529  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4530  , m_dispatcher( device.getDispatcher() )
4531  {
4533  device.getDispatcher()->vkCreateBufferCollectionFUCHSIA( static_cast<VkDevice>( *device ),
4534  reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( &createInfo ),
4535  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4536  reinterpret_cast<VkBufferCollectionFUCHSIA *>( &m_collection ) ) );
4538  {
4539  throwResultException( result, "vkCreateBufferCollectionFUCHSIA" );
4540  }
4541  }
4542 
4543  BufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4544  VkBufferCollectionFUCHSIA collection,
4546  : m_device( *device )
4547  , m_collection( collection )
4548  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4549  , m_dispatcher( device.getDispatcher() )
4550  {
4551  }
4552 
4553  BufferCollectionFUCHSIA( std::nullptr_t ) {}
4554 
4555  ~BufferCollectionFUCHSIA()
4556  {
4557  clear();
4558  }
4559 
4560  BufferCollectionFUCHSIA() = delete;
4561  BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & ) = delete;
4562  BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
4563  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4564  , m_collection( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_collection, {} ) )
4565  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4566  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
4567  {
4568  }
4569  BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete;
4570  BufferCollectionFUCHSIA & operator =( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
4571  {
4572  if ( this != &rhs )
4573  {
4574  clear();
4575  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
4576  m_collection = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_collection, {} );
4577  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
4578  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
4579  }
4580  return *this;
4581  }
4582 
4583  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & operator*() const VULKAN_HPP_NOEXCEPT
4584  {
4585  return m_collection;
4586  }
4587 
4588  void clear() VULKAN_HPP_NOEXCEPT
4589  {
4590  if ( m_collection )
4591  {
4592  getDispatcher()->vkDestroyBufferCollectionFUCHSIA( static_cast<VkDevice>( m_device ),
4593  static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
4594  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4595  }
4596  m_device = nullptr;
4597  m_collection = nullptr;
4598  m_allocator = nullptr;
4599  m_dispatcher = nullptr;
4600  }
4601 
4602  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA release()
4603  {
4604  m_device = nullptr;
4605  m_allocator = nullptr;
4606  m_dispatcher = nullptr;
4607  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_collection, nullptr );
4608  }
4609 
4610  VULKAN_HPP_NAMESPACE::Device getDevice() const
4611  {
4612  return m_device;
4613  }
4614 
4616  {
4617  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4618  return m_dispatcher;
4619  }
4620 
4621  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA & rhs ) VULKAN_HPP_NOEXCEPT
4622  {
4623  std::swap( m_device, rhs.m_device );
4624  std::swap( m_collection, rhs.m_collection );
4625  std::swap( m_allocator, rhs.m_allocator );
4626  std::swap( m_dispatcher, rhs.m_dispatcher );
4627  }
4628 
4629  //=== VK_FUCHSIA_buffer_collection ===
4630 
4631  void setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const;
4632 
4633  void setBufferConstraints( const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const;
4634 
4635  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties() const;
4636 
4637  private:
4638  VULKAN_HPP_NAMESPACE::Device m_device = {};
4639  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_collection = {};
4640  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4642  };
4643 # endif /*VK_USE_PLATFORM_FUCHSIA*/
4644 
4646  {
4647  public:
4648  using CType = VkBufferView;
4649 
4653 
4654  public:
4656  VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo,
4658  : m_device( *device )
4659  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4660  , m_dispatcher( device.getDispatcher() )
4661  {
4663  device.getDispatcher()->vkCreateBufferView( static_cast<VkDevice>( *device ),
4664  reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
4665  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4666  reinterpret_cast<VkBufferView *>( &m_bufferView ) ) );
4668  {
4669  throwResultException( result, "vkCreateBufferView" );
4670  }
4671  }
4672 
4674  VkBufferView bufferView,
4676  : m_device( *device )
4677  , m_bufferView( bufferView )
4678  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4679  , m_dispatcher( device.getDispatcher() )
4680  {
4681  }
4682 
4683  BufferView( std::nullptr_t ) {}
4684 
4686  {
4687  clear();
4688  }
4689 
4690  BufferView() = delete;
4691  BufferView( BufferView const & ) = delete;
4692  BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
4693  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4694  , m_bufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} ) )
4695  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4697  {
4698  }
4699  BufferView & operator=( BufferView const & ) = delete;
4700  BufferView & operator =( BufferView && rhs ) VULKAN_HPP_NOEXCEPT
4701  {
4702  if ( this != &rhs )
4703  {
4704  clear();
4705  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
4706  m_bufferView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} );
4707  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
4708  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
4709  }
4710  return *this;
4711  }
4712 
4713  VULKAN_HPP_NAMESPACE::BufferView const & operator*() const VULKAN_HPP_NOEXCEPT
4714  {
4715  return m_bufferView;
4716  }
4717 
4718  void clear() VULKAN_HPP_NOEXCEPT
4719  {
4720  if ( m_bufferView )
4721  {
4722  getDispatcher()->vkDestroyBufferView(
4723  static_cast<VkDevice>( m_device ), static_cast<VkBufferView>( m_bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4724  }
4725  m_device = nullptr;
4726  m_bufferView = nullptr;
4727  m_allocator = nullptr;
4728  m_dispatcher = nullptr;
4729  }
4730 
4732  {
4733  m_device = nullptr;
4734  m_allocator = nullptr;
4735  m_dispatcher = nullptr;
4736  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_bufferView, nullptr );
4737  }
4738 
4740  {
4741  return m_device;
4742  }
4743 
4745  {
4746  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4747  return m_dispatcher;
4748  }
4749 
4751  {
4752  std::swap( m_device, rhs.m_device );
4753  std::swap( m_bufferView, rhs.m_bufferView );
4754  std::swap( m_allocator, rhs.m_allocator );
4755  std::swap( m_dispatcher, rhs.m_dispatcher );
4756  }
4757 
4758  private:
4759  VULKAN_HPP_NAMESPACE::Device m_device = {};
4760  VULKAN_HPP_NAMESPACE::BufferView m_bufferView = {};
4761  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4763  };
4764 
4766  {
4767  public:
4768  using CType = VkCommandPool;
4769 
4773 
4774  public:
4778  : m_device( *device )
4779  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4780  , m_dispatcher( device.getDispatcher() )
4781  {
4783  device.getDispatcher()->vkCreateCommandPool( static_cast<VkDevice>( *device ),
4784  reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
4785  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4786  reinterpret_cast<VkCommandPool *>( &m_commandPool ) ) );
4788  {
4789  throwResultException( result, "vkCreateCommandPool" );
4790  }
4791  }
4792 
4794  VkCommandPool commandPool,
4796  : m_device( *device )
4797  , m_commandPool( commandPool )
4798  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4799  , m_dispatcher( device.getDispatcher() )
4800  {
4801  }
4802 
4803  CommandPool( std::nullptr_t ) {}
4804 
4806  {
4807  clear();
4808  }
4809 
4810  CommandPool() = delete;
4811  CommandPool( CommandPool const & ) = delete;
4812  CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
4813  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4814  , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) )
4815  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4817  {
4818  }
4819  CommandPool & operator=( CommandPool const & ) = delete;
4820  CommandPool & operator =( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT
4821  {
4822  if ( this != &rhs )
4823  {
4824  clear();
4825  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
4826  m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} );
4827  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
4828  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
4829  }
4830  return *this;
4831  }
4832 
4833  VULKAN_HPP_NAMESPACE::CommandPool const & operator*() const VULKAN_HPP_NOEXCEPT
4834  {
4835  return m_commandPool;
4836  }
4837 
4838  void clear() VULKAN_HPP_NOEXCEPT
4839  {
4840  if ( m_commandPool )
4841  {
4842  getDispatcher()->vkDestroyCommandPool(
4843  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4844  }
4845  m_device = nullptr;
4846  m_commandPool = nullptr;
4847  m_allocator = nullptr;
4848  m_dispatcher = nullptr;
4849  }
4850 
4852  {
4853  m_device = nullptr;
4854  m_allocator = nullptr;
4855  m_dispatcher = nullptr;
4856  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_commandPool, nullptr );
4857  }
4858 
4860  {
4861  return m_device;
4862  }
4863 
4865  {
4866  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4867  return m_dispatcher;
4868  }
4869 
4871  {
4872  std::swap( m_device, rhs.m_device );
4873  std::swap( m_commandPool, rhs.m_commandPool );
4874  std::swap( m_allocator, rhs.m_allocator );
4875  std::swap( m_dispatcher, rhs.m_dispatcher );
4876  }
4877 
4878  //=== VK_VERSION_1_0 ===
4879 
4881 
4882  //=== VK_VERSION_1_1 ===
4883 
4885 
4886  //=== VK_KHR_maintenance1 ===
4887 
4889 
4890  private:
4891  VULKAN_HPP_NAMESPACE::Device m_device = {};
4892  VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {};
4893  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4895  };
4896 
4898  {
4899  public:
4900  using CType = VkCommandBuffer;
4901 
4905 
4906  public:
4907  CommandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkCommandBuffer commandBuffer, VkCommandPool commandPool )
4908  : m_device( *device ), m_commandPool( commandPool ), m_commandBuffer( commandBuffer ), m_dispatcher( device.getDispatcher() )
4909  {
4910  }
4911 
4912  CommandBuffer( std::nullptr_t ) {}
4913 
4915  {
4916  clear();
4917  }
4918 
4919  CommandBuffer() = delete;
4920  CommandBuffer( CommandBuffer const & ) = delete;
4921  CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
4922  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4923  , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) )
4924  , m_commandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) )
4926  {
4927  }
4928  CommandBuffer & operator=( CommandBuffer const & ) = delete;
4929  CommandBuffer & operator =( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT
4930  {
4931  if ( this != &rhs )
4932  {
4933  clear();
4934  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
4935  m_commandPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} );
4936  m_commandBuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} );
4937  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
4938  }
4939  return *this;
4940  }
4941 
4942  VULKAN_HPP_NAMESPACE::CommandBuffer const & operator*() const VULKAN_HPP_NOEXCEPT
4943  {
4944  return m_commandBuffer;
4945  }
4946 
4947  void clear() VULKAN_HPP_NOEXCEPT
4948  {
4949  if ( m_commandBuffer )
4950  {
4951  getDispatcher()->vkFreeCommandBuffers(
4952  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), 1, reinterpret_cast<VkCommandBuffer const *>( &m_commandBuffer ) );
4953  }
4954  m_device = nullptr;
4955  m_commandPool = nullptr;
4956  m_commandBuffer = nullptr;
4957  m_dispatcher = nullptr;
4958  }
4959 
4961  {
4962  m_device = nullptr;
4963  m_commandPool = nullptr;
4964  m_dispatcher = nullptr;
4965  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_commandBuffer, nullptr );
4966  }
4967 
4969  {
4970  return m_device;
4971  }
4972 
4974  {
4975  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4976  return m_dispatcher;
4977  }
4978 
4980  {
4981  std::swap( m_device, rhs.m_device );
4982  std::swap( m_commandPool, rhs.m_commandPool );
4983  std::swap( m_commandBuffer, rhs.m_commandBuffer );
4984  std::swap( m_dispatcher, rhs.m_dispatcher );
4985  }
4986 
4987  //=== VK_VERSION_1_0 ===
4988 
4989  void begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const;
4990 
4991  void end() const;
4992 
4994 
4995  void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT;
4996 
4997  void setViewport( uint32_t firstViewport,
4999 
5000  void setScissor( uint32_t firstScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT;
5001 
5002  void setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT;
5003 
5004  void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT;
5005 
5006  void setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT;
5007 
5008  void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT;
5009 
5010  void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT;
5011 
5012  void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT;
5013 
5014  void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT;
5015 
5016  void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
5018  uint32_t firstSet,
5021 
5022  void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer,
5025 
5026  void bindVertexBuffers( uint32_t firstBinding,
5029 
5030  void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
5031 
5032  void
5033  drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
5034 
5035  void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
5037  uint32_t drawCount,
5038  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5039 
5040  void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
5042  uint32_t drawCount,
5043  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5044 
5045  void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
5046 
5048 
5049  void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
5050  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5052 
5053  void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
5054  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
5055  VULKAN_HPP_NAMESPACE::Image dstImage,
5056  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5058 
5059  void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
5060  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
5061  VULKAN_HPP_NAMESPACE::Image dstImage,
5062  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5065 
5066  void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
5067  VULKAN_HPP_NAMESPACE::Image dstImage,
5068  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5070 
5071  void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage,
5072  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
5073  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5075 
5076  template <typename DataType>
5077  void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5080 
5081  void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5084  uint32_t data ) const VULKAN_HPP_NOEXCEPT;
5085 
5086  void clearColorImage( VULKAN_HPP_NAMESPACE::Image image,
5090 
5091  void
5092  clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image,
5094  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil,
5096 
5099 
5100  void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage,
5101  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
5102  VULKAN_HPP_NAMESPACE::Image dstImage,
5103  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5105 
5106  void setEvent( VULKAN_HPP_NAMESPACE::Event event,
5108 
5109  void resetEvent( VULKAN_HPP_NAMESPACE::Event event,
5111 
5118 
5119  void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,
5121  VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
5126 
5127  void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5128  uint32_t query,
5130 
5131  void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT;
5132 
5133  void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT;
5134 
5135  void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
5137  uint32_t query ) const VULKAN_HPP_NOEXCEPT;
5138 
5139  void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5140  uint32_t firstQuery,
5141  uint32_t queryCount,
5142  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5146 
5147  template <typename ValuesType>
5148  void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5150  uint32_t offset,
5152 
5153  void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5155 
5156  void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT;
5157 
5158  void endRenderPass() const VULKAN_HPP_NOEXCEPT;
5159 
5160  void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const VULKAN_HPP_NOEXCEPT;
5161 
5162  //=== VK_VERSION_1_1 ===
5163 
5164  void setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
5165 
5166  void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
5167  VULKAN_HPP_NOEXCEPT;
5168 
5169  //=== VK_VERSION_1_2 ===
5170 
5171  void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
5173  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5174  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5175  uint32_t maxDrawCount,
5176  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5177 
5178  void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
5180  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5181  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5182  uint32_t maxDrawCount,
5183  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5184 
5185  void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5186  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT;
5187 
5188  void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5189  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
5190 
5191  void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
5192 
5193  //=== VK_VERSION_1_3 ===
5194 
5195  void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
5196 
5197  void resetEvent2( VULKAN_HPP_NAMESPACE::Event event,
5199 
5200  void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
5201  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos ) const;
5202 
5203  void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
5204 
5205  void
5206  writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT;
5207 
5208  void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT;
5209 
5210  void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT;
5211 
5212  void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT;
5213 
5214  void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT;
5215 
5216  void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT;
5217 
5218  void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT;
5219 
5220  void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT;
5221 
5222  void endRendering() const VULKAN_HPP_NOEXCEPT;
5223 
5224  void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5225 
5226  void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT;
5227 
5228  void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT;
5229 
5230  void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT;
5231 
5232  void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT;
5233 
5234  void bindVertexBuffers2(
5235  uint32_t firstBinding,
5239  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
5240 
5241  void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT;
5242 
5243  void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT;
5244 
5245  void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT;
5246 
5247  void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT;
5248 
5249  void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT;
5250 
5251  void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5254  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
5255  VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT;
5256 
5257  void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT;
5258 
5259  void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT;
5260 
5261  void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT;
5262 
5263  //=== VK_EXT_debug_marker ===
5264 
5265  void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT;
5266 
5267  void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT;
5268 
5269  void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT;
5270 
5271 # if defined( VK_ENABLE_BETA_EXTENSIONS )
5272  //=== VK_KHR_video_queue ===
5273 
5274  void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT;
5275 
5276  void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT;
5277 
5278  void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT;
5279 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
5280 
5281 # if defined( VK_ENABLE_BETA_EXTENSIONS )
5282  //=== VK_KHR_video_decode_queue ===
5283 
5284  void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT;
5285 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
5286 
5287  //=== VK_EXT_transform_feedback ===
5288 
5289  void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
5293  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
5294 
5295  void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
5298  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
5299 
5300  void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
5303  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
5304 
5305  void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5306  uint32_t query,
5308  uint32_t index ) const VULKAN_HPP_NOEXCEPT;
5309 
5310  void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT;
5311 
5312  void drawIndirectByteCountEXT( uint32_t instanceCount,
5313  uint32_t firstInstance,
5314  VULKAN_HPP_NAMESPACE::Buffer counterBuffer,
5315  VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
5316  uint32_t counterOffset,
5317  uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT;
5318 
5319  //=== VK_NVX_binary_import ===
5320 
5321  void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT;
5322 
5323  //=== VK_AMD_draw_indirect_count ===
5324 
5325  void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
5327  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5328  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5329  uint32_t maxDrawCount,
5330  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5331 
5332  void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
5334  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5335  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5336  uint32_t maxDrawCount,
5337  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5338 
5339  //=== VK_KHR_dynamic_rendering ===
5340 
5341  void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT;
5342 
5343  void endRenderingKHR() const VULKAN_HPP_NOEXCEPT;
5344 
5345  //=== VK_KHR_device_group ===
5346 
5347  void setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
5348 
5349  void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ )
5350  const VULKAN_HPP_NOEXCEPT;
5351 
5352  //=== VK_KHR_push_descriptor ===
5353 
5354  void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
5356  uint32_t set,
5357  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const
5358  VULKAN_HPP_NOEXCEPT;
5359 
5360  template <typename DataType>
5361  void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5363  uint32_t set,
5364  DataType const & data ) const VULKAN_HPP_NOEXCEPT;
5365 
5366  //=== VK_EXT_conditional_rendering ===
5367 
5368  void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT;
5369 
5370  void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT;
5371 
5372  //=== VK_NV_clip_space_w_scaling ===
5373 
5374  void setViewportWScalingNV( uint32_t firstViewport,
5375  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) const
5376  VULKAN_HPP_NOEXCEPT;
5377 
5378  //=== VK_EXT_discard_rectangles ===
5379 
5380  void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
5381  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT;
5382 
5383  //=== VK_KHR_create_renderpass2 ===
5384 
5385  void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5386  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT;
5387 
5388  void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5389  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
5390 
5391  void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
5392 
5393  //=== VK_EXT_debug_utils ===
5394 
5395  void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
5396 
5397  void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT;
5398 
5399  void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
5400 
5401  //=== VK_EXT_sample_locations ===
5402 
5403  void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT;
5404 
5405  //=== VK_KHR_acceleration_structure ===
5406 
5407  void buildAccelerationStructuresKHR(
5409  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) const;
5410 
5411  void buildAccelerationStructuresIndirectKHR(
5413  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses,
5414  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides,
5415  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const;
5416 
5417  void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
5418 
5419  void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
5420 
5421  void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
5422 
5423  void writeAccelerationStructuresPropertiesKHR(
5424  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
5425  VULKAN_HPP_NAMESPACE::QueryType queryType,
5426  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5427  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT;
5428 
5429  //=== VK_NV_shading_rate_image ===
5430 
5431  void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT;
5432 
5433  void setViewportShadingRatePaletteNV(
5434  uint32_t firstViewport,
5435  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT;
5436 
5437  void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,
5438  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders ) const
5439  VULKAN_HPP_NOEXCEPT;
5440 
5441  //=== VK_NV_ray_tracing ===
5442 
5443  void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
5444  VULKAN_HPP_NAMESPACE::Buffer instanceData,
5445  VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
5446  VULKAN_HPP_NAMESPACE::Bool32 update,
5449  VULKAN_HPP_NAMESPACE::Buffer scratch,
5450  VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT;
5451 
5452  void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
5454  VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT;
5455 
5456  void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer,
5457  VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
5458  VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer,
5459  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
5460  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
5461  VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer,
5462  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
5463  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
5464  VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,
5465  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
5466  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
5467  uint32_t width,
5468  uint32_t height,
5469  uint32_t depth ) const VULKAN_HPP_NOEXCEPT;
5470 
5471  void writeAccelerationStructuresPropertiesNV(
5472  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
5473  VULKAN_HPP_NAMESPACE::QueryType queryType,
5474  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5475  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT;
5476 
5477  //=== VK_KHR_draw_indirect_count ===
5478 
5479  void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
5481  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5482  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5483  uint32_t maxDrawCount,
5484  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5485 
5486  void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
5488  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5489  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5490  uint32_t maxDrawCount,
5491  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5492 
5493  //=== VK_AMD_buffer_marker ===
5494 
5495  void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
5496  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5497  VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
5498  uint32_t marker ) const VULKAN_HPP_NOEXCEPT;
5499 
5500  //=== VK_NV_mesh_shader ===
5501 
5502  void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT;
5503 
5504  void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
5506  uint32_t drawCount,
5507  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5508 
5509  void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
5511  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5512  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5513  uint32_t maxDrawCount,
5514  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5515 
5516  //=== VK_NV_scissor_exclusive ===
5517 
5518  void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
5519  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT;
5520 
5521  //=== VK_NV_device_diagnostic_checkpoints ===
5522 
5523  template <typename CheckpointMarkerType>
5524  void setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT;
5525 
5526  //=== VK_INTEL_performance_query ===
5527 
5528  void setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo ) const;
5529 
5530  void setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo ) const;
5531 
5532  void setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo ) const;
5533 
5534  //=== VK_KHR_fragment_shading_rate ===
5535 
5536  void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize,
5537  const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT;
5538 
5539  //=== VK_EXT_line_rasterization ===
5540 
5541  void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT;
5542 
5543  //=== VK_EXT_extended_dynamic_state ===
5544 
5545  void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5546 
5547  void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT;
5548 
5549  void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT;
5550 
5551  void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT;
5552 
5553  void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT;
5554 
5555  void bindVertexBuffers2EXT(
5556  uint32_t firstBinding,
5559  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5560  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
5561 
5562  void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT;
5563 
5564  void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT;
5565 
5566  void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT;
5567 
5568  void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT;
5569 
5570  void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT;
5571 
5572  void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5575  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
5576  VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT;
5577 
5578  //=== VK_NV_device_generated_commands ===
5579 
5580  void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT;
5581 
5582  void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,
5583  const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT;
5584 
5585  void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
5586  VULKAN_HPP_NAMESPACE::Pipeline pipeline,
5587  uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT;
5588 
5589 # if defined( VK_ENABLE_BETA_EXTENSIONS )
5590  //=== VK_KHR_video_encode_queue ===
5591 
5592  void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT;
5593 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
5594 
5595  //=== VK_KHR_synchronization2 ===
5596 
5597  void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
5598 
5599  void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
5601 
5602  void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
5604 
5605  void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
5606 
5607  void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
5609  uint32_t query ) const VULKAN_HPP_NOEXCEPT;
5610 
5611  void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
5612  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5614  uint32_t marker ) const VULKAN_HPP_NOEXCEPT;
5615 
5616  //=== VK_EXT_descriptor_buffer ===
5617 
5618  void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos ) const
5620 
5621  void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
5623  uint32_t firstSet,
5626 
5627  void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
5629  uint32_t set ) const VULKAN_HPP_NOEXCEPT;
5630 
5631  //=== VK_NV_fragment_shading_rate_enums ===
5632 
5633  void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate,
5635 
5636  //=== VK_EXT_mesh_shader ===
5637 
5638  void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
5639 
5640  void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
5642  uint32_t drawCount,
5643  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5644 
5645  void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
5647  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5648  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5649  uint32_t maxDrawCount,
5650  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5651 
5652  //=== VK_KHR_copy_commands2 ===
5653 
5654  void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT;
5655 
5656  void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT;
5657 
5658  void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT;
5659 
5660  void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT;
5661 
5662  void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT;
5663 
5664  void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT;
5665 
5666  //=== VK_KHR_ray_tracing_pipeline ===
5667 
5668  void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5669  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5670  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5671  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5672  uint32_t width,
5673  uint32_t height,
5674  uint32_t depth ) const VULKAN_HPP_NOEXCEPT;
5675 
5676  void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5677  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5678  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5679  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5680  VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT;
5681 
5682  void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT;
5683 
5684  //=== VK_EXT_vertex_input_dynamic_state ===
5685 
5686  void setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
5688  vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT;
5689 
5690  //=== VK_HUAWEI_subpass_shading ===
5691 
5692  void subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT;
5693 
5694  //=== VK_HUAWEI_invocation_mask ===
5695 
5696  void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT;
5697 
5698  //=== VK_EXT_extended_dynamic_state2 ===
5699 
5700  void setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT;
5701 
5702  void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT;
5703 
5704  void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT;
5705 
5706  void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT;
5707 
5708  void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT;
5709 
5710  //=== VK_EXT_color_write_enable ===
5711 
5712  void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT;
5713 
5714  //=== VK_KHR_ray_tracing_maintenance1 ===
5715 
5716  void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT;
5717 
5718  //=== VK_EXT_multi_draw ===
5719 
5720  void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
5721  uint32_t instanceCount,
5722  uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
5723 
5724  void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
5725  uint32_t instanceCount,
5726  uint32_t firstInstance,
5727  Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5728 
5729  //=== VK_EXT_opacity_micromap ===
5730 
5731  void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos ) const VULKAN_HPP_NOEXCEPT;
5732 
5733  void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT;
5734 
5735  void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT;
5736 
5737  void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT;
5738 
5739  void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
5740  VULKAN_HPP_NAMESPACE::QueryType queryType,
5741  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5742  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT;
5743 
5744  //=== VK_NV_copy_memory_indirect ===
5745 
5746  void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5747 
5748  void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,
5749  uint32_t stride,
5750  VULKAN_HPP_NAMESPACE::Image dstImage,
5751  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5752  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources ) const
5753  VULKAN_HPP_NOEXCEPT;
5754 
5755  //=== VK_NV_memory_decompression ===
5756 
5757  void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions ) const
5758  VULKAN_HPP_NOEXCEPT;
5759 
5760  void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,
5761  VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,
5762  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5763 
5764  //=== VK_EXT_extended_dynamic_state3 ===
5765 
5766  void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT;
5767 
5768  void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT;
5769 
5770  void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT;
5771 
5772  void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT;
5773 
5774  void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
5775  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask ) const VULKAN_HPP_NOEXCEPT;
5776 
5777  void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT;
5778 
5779  void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT;
5780 
5781  void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT;
5782 
5783  void setColorBlendEnableEXT( uint32_t firstAttachment,
5784  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT;
5785 
5786  void setColorBlendEquationEXT( uint32_t firstAttachment,
5787  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations ) const
5788  VULKAN_HPP_NOEXCEPT;
5789 
5790  void setColorWriteMaskEXT( uint32_t firstAttachment,
5791  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks ) const
5792  VULKAN_HPP_NOEXCEPT;
5793 
5794  void setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT;
5795 
5796  void
5797  setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT;
5798 
5799  void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT;
5800 
5801  void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT;
5802 
5803  void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT;
5804 
5805  void setColorBlendAdvancedEXT( uint32_t firstAttachment,
5806  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced ) const
5807  VULKAN_HPP_NOEXCEPT;
5808 
5809  void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT;
5810 
5811  void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT;
5812 
5813  void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT;
5814 
5815  void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT;
5816 
5817  void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT;
5818 
5819  void setViewportSwizzleNV( uint32_t firstViewport,
5820  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles ) const
5821  VULKAN_HPP_NOEXCEPT;
5822 
5823  void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT;
5824 
5825  void setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT;
5826 
5827  void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT;
5828 
5829  void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT;
5830 
5831  void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT;
5832 
5833  void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT;
5834 
5835  void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT;
5836 
5837  void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT;
5838 
5839  //=== VK_NV_optical_flow ===
5840 
5841  void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
5842  const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT;
5843 
5844  private:
5845  VULKAN_HPP_NAMESPACE::Device m_device = {};
5846  VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {};
5847  VULKAN_HPP_NAMESPACE::CommandBuffer m_commandBuffer = {};
5849  };
5850 
5851  class CommandBuffers : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>
5852  {
5853  public:
5856  {
5858  std::vector<VkCommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
5860  static_cast<VkDevice>( *device ), reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), commandBuffers.data() ) );
5862  {
5863  this->reserve( allocateInfo.commandBufferCount );
5864  for ( auto const & commandBuffer : commandBuffers )
5865  {
5866  this->emplace_back( device, commandBuffer, static_cast<VkCommandPool>( allocateInfo.commandPool ) );
5867  }
5868  }
5869  else
5870  {
5871  throwResultException( result, "vkAllocateCommandBuffers" );
5872  }
5873  }
5874 
5875  CommandBuffers( std::nullptr_t ) {}
5876 
5877  CommandBuffers() = delete;
5878  CommandBuffers( CommandBuffers const & ) = delete;
5879  CommandBuffers( CommandBuffers && rhs ) = default;
5880  CommandBuffers & operator=( CommandBuffers const & ) = delete;
5881  CommandBuffers & operator=( CommandBuffers && rhs ) = default;
5882  };
5883 
5885  {
5886  public:
5887  using CType = VkCuFunctionNVX;
5888 
5892 
5893  public:
5897  : m_device( *device )
5898  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
5899  , m_dispatcher( device.getDispatcher() )
5900  {
5902  device.getDispatcher()->vkCreateCuFunctionNVX( static_cast<VkDevice>( *device ),
5903  reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
5904  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
5905  reinterpret_cast<VkCuFunctionNVX *>( &m_function ) ) );
5907  {
5908  throwResultException( result, "vkCreateCuFunctionNVX" );
5909  }
5910  }
5911 
5913  VkCuFunctionNVX function,
5915  : m_device( *device )
5916  , m_function( function )
5917  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
5918  , m_dispatcher( device.getDispatcher() )
5919  {
5920  }
5921 
5922  CuFunctionNVX( std::nullptr_t ) {}
5923 
5925  {
5926  clear();
5927  }
5928 
5929  CuFunctionNVX() = delete;
5930  CuFunctionNVX( CuFunctionNVX const & ) = delete;
5931  CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT
5932  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
5933  , m_function( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} ) )
5934  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
5936  {
5937  }
5938  CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete;
5939  CuFunctionNVX & operator =( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT
5940  {
5941  if ( this != &rhs )
5942  {
5943  clear();
5944  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
5945  m_function = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} );
5946  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
5947  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
5948  }
5949  return *this;
5950  }
5951 
5952  VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT
5953  {
5954  return m_function;
5955  }
5956 
5957  void clear() VULKAN_HPP_NOEXCEPT
5958  {
5959  if ( m_function )
5960  {
5961  getDispatcher()->vkDestroyCuFunctionNVX(
5962  static_cast<VkDevice>( m_device ), static_cast<VkCuFunctionNVX>( m_function ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
5963  }
5964  m_device = nullptr;
5965  m_function = nullptr;
5966  m_allocator = nullptr;
5967  m_dispatcher = nullptr;
5968  }
5969 
5971  {
5972  m_device = nullptr;
5973  m_allocator = nullptr;
5974  m_dispatcher = nullptr;
5975  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_function, nullptr );
5976  }
5977 
5979  {
5980  return m_device;
5981  }
5982 
5984  {
5985  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
5986  return m_dispatcher;
5987  }
5988 
5990  {
5991  std::swap( m_device, rhs.m_device );
5992  std::swap( m_function, rhs.m_function );
5993  std::swap( m_allocator, rhs.m_allocator );
5994  std::swap( m_dispatcher, rhs.m_dispatcher );
5995  }
5996 
5997  private:
5998  VULKAN_HPP_NAMESPACE::Device m_device = {};
5999  VULKAN_HPP_NAMESPACE::CuFunctionNVX m_function = {};
6000  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6002  };
6003 
6005  {
6006  public:
6007  using CType = VkCuModuleNVX;
6008 
6012 
6013  public:
6017  : m_device( *device )
6018  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6019  , m_dispatcher( device.getDispatcher() )
6020  {
6022  device.getDispatcher()->vkCreateCuModuleNVX( static_cast<VkDevice>( *device ),
6023  reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
6024  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6025  reinterpret_cast<VkCuModuleNVX *>( &m_module ) ) );
6027  {
6028  throwResultException( result, "vkCreateCuModuleNVX" );
6029  }
6030  }
6031 
6033  VkCuModuleNVX module,
6035  : m_device( *device )
6036  , m_module( module )
6037  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6038  , m_dispatcher( device.getDispatcher() )
6039  {
6040  }
6041 
6042  CuModuleNVX( std::nullptr_t ) {}
6043 
6045  {
6046  clear();
6047  }
6048 
6049  CuModuleNVX() = delete;
6050  CuModuleNVX( CuModuleNVX const & ) = delete;
6052  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6053  , m_module( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} ) )
6054  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6056  {
6057  }
6058  CuModuleNVX & operator=( CuModuleNVX const & ) = delete;
6060  {
6061  if ( this != &rhs )
6062  {
6063  clear();
6064  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
6065  m_module = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} );
6066  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
6067  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
6068  }
6069  return *this;
6070  }
6071 
6073  {
6074  return m_module;
6075  }
6076 
6078  {
6079  if ( m_module )
6080  {
6081  getDispatcher()->vkDestroyCuModuleNVX(
6082  static_cast<VkDevice>( m_device ), static_cast<VkCuModuleNVX>( m_module ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6083  }
6084  m_device = nullptr;
6085  m_module = nullptr;
6086  m_allocator = nullptr;
6087  m_dispatcher = nullptr;
6088  }
6089 
6091  {
6092  m_device = nullptr;
6093  m_allocator = nullptr;
6094  m_dispatcher = nullptr;
6096  }
6097 
6099  {
6100  return m_device;
6101  }
6102 
6104  {
6105  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6106  return m_dispatcher;
6107  }
6108 
6110  {
6111  std::swap( m_device, rhs.m_device );
6112  std::swap( m_module, rhs.m_module );
6113  std::swap( m_allocator, rhs.m_allocator );
6114  std::swap( m_dispatcher, rhs.m_dispatcher );
6115  }
6116 
6117  private:
6118  VULKAN_HPP_NAMESPACE::Device m_device = {};
6119  VULKAN_HPP_NAMESPACE::CuModuleNVX m_module = {};
6120  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6122  };
6123 
6125  {
6126  public:
6127  using CType = VkDebugReportCallbackEXT;
6128 
6132 
6133  public:
6137  : m_instance( *instance )
6138  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6139  , m_dispatcher( instance.getDispatcher() )
6140  {
6142  instance.getDispatcher()->vkCreateDebugReportCallbackEXT( static_cast<VkInstance>( *instance ),
6143  reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
6144  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6145  reinterpret_cast<VkDebugReportCallbackEXT *>( &m_callback ) ) );
6147  {
6148  throwResultException( result, "vkCreateDebugReportCallbackEXT" );
6149  }
6150  }
6151 
6153  VkDebugReportCallbackEXT callback,
6155  : m_instance( *instance )
6156  , m_callback( callback )
6157  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6158  , m_dispatcher( instance.getDispatcher() )
6159  {
6160  }
6161 
6162  DebugReportCallbackEXT( std::nullptr_t ) {}
6163 
6165  {
6166  clear();
6167  }
6168 
6169  DebugReportCallbackEXT() = delete;
6170  DebugReportCallbackEXT( DebugReportCallbackEXT const & ) = delete;
6172  : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
6173  , m_callback( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_callback, {} ) )
6174  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6176  {
6177  }
6180  {
6181  if ( this != &rhs )
6182  {
6183  clear();
6184  m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
6185  m_callback = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_callback, {} );
6186  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
6187  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
6188  }
6189  return *this;
6190  }
6191 
6193  {
6194  return m_callback;
6195  }
6196 
6198  {
6199  if ( m_callback )
6200  {
6201  getDispatcher()->vkDestroyDebugReportCallbackEXT( static_cast<VkInstance>( m_instance ),
6202  static_cast<VkDebugReportCallbackEXT>( m_callback ),
6203  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6204  }
6205  m_instance = nullptr;
6206  m_callback = nullptr;
6207  m_allocator = nullptr;
6208  m_dispatcher = nullptr;
6209  }
6210 
6212  {
6213  m_instance = nullptr;
6214  m_allocator = nullptr;
6215  m_dispatcher = nullptr;
6216  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_callback, nullptr );
6217  }
6218 
6220  {
6221  return m_instance;
6222  }
6223 
6225  {
6226  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6227  return m_dispatcher;
6228  }
6229 
6231  {
6232  std::swap( m_instance, rhs.m_instance );
6233  std::swap( m_callback, rhs.m_callback );
6234  std::swap( m_allocator, rhs.m_allocator );
6235  std::swap( m_dispatcher, rhs.m_dispatcher );
6236  }
6237 
6238  private:
6239  VULKAN_HPP_NAMESPACE::Instance m_instance = {};
6241  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6243  };
6244 
6246  {
6247  public:
6248  using CType = VkDebugUtilsMessengerEXT;
6249 
6253 
6254  public:
6258  : m_instance( *instance )
6259  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6260  , m_dispatcher( instance.getDispatcher() )
6261  {
6263  instance.getDispatcher()->vkCreateDebugUtilsMessengerEXT( static_cast<VkInstance>( *instance ),
6264  reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
6265  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6266  reinterpret_cast<VkDebugUtilsMessengerEXT *>( &m_messenger ) ) );
6268  {
6269  throwResultException( result, "vkCreateDebugUtilsMessengerEXT" );
6270  }
6271  }
6272 
6274  VkDebugUtilsMessengerEXT messenger,
6276  : m_instance( *instance )
6277  , m_messenger( messenger )
6278  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6279  , m_dispatcher( instance.getDispatcher() )
6280  {
6281  }
6282 
6283  DebugUtilsMessengerEXT( std::nullptr_t ) {}
6284 
6286  {
6287  clear();
6288  }
6289 
6290  DebugUtilsMessengerEXT() = delete;
6291  DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & ) = delete;
6293  : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
6294  , m_messenger( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} ) )
6295  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6297  {
6298  }
6301  {
6302  if ( this != &rhs )
6303  {
6304  clear();
6305  m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
6306  m_messenger = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} );
6307  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
6308  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
6309  }
6310  return *this;
6311  }
6312 
6314  {
6315  return m_messenger;
6316  }
6317 
6319  {
6320  if ( m_messenger )
6321  {
6322  getDispatcher()->vkDestroyDebugUtilsMessengerEXT( static_cast<VkInstance>( m_instance ),
6323  static_cast<VkDebugUtilsMessengerEXT>( m_messenger ),
6324  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6325  }
6326  m_instance = nullptr;
6327  m_messenger = nullptr;
6328  m_allocator = nullptr;
6329  m_dispatcher = nullptr;
6330  }
6331 
6333  {
6334  m_instance = nullptr;
6335  m_allocator = nullptr;
6336  m_dispatcher = nullptr;
6337  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_messenger, nullptr );
6338  }
6339 
6341  {
6342  return m_instance;
6343  }
6344 
6346  {
6347  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6348  return m_dispatcher;
6349  }
6350 
6352  {
6353  std::swap( m_instance, rhs.m_instance );
6354  std::swap( m_messenger, rhs.m_messenger );
6355  std::swap( m_allocator, rhs.m_allocator );
6356  std::swap( m_dispatcher, rhs.m_dispatcher );
6357  }
6358 
6359  private:
6360  VULKAN_HPP_NAMESPACE::Instance m_instance = {};
6362  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6364  };
6365 
6367  {
6368  public:
6369  using CType = VkDeferredOperationKHR;
6370 
6374 
6375  public:
6378  : m_device( *device )
6379  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6380  , m_dispatcher( device.getDispatcher() )
6381  {
6383  device.getDispatcher()->vkCreateDeferredOperationKHR( static_cast<VkDevice>( *device ),
6384  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6385  reinterpret_cast<VkDeferredOperationKHR *>( &m_operation ) ) );
6387  {
6388  throwResultException( result, "vkCreateDeferredOperationKHR" );
6389  }
6390  }
6391 
6393  VkDeferredOperationKHR operation,
6395  : m_device( *device )
6396  , m_operation( operation )
6397  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6398  , m_dispatcher( device.getDispatcher() )
6399  {
6400  }
6401 
6402  DeferredOperationKHR( std::nullptr_t ) {}
6403 
6405  {
6406  clear();
6407  }
6408 
6409  DeferredOperationKHR() = delete;
6410  DeferredOperationKHR( DeferredOperationKHR const & ) = delete;
6412  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6413  , m_operation( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_operation, {} ) )
6414  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6416  {
6417  }
6418  DeferredOperationKHR & operator=( DeferredOperationKHR const & ) = delete;
6420  {
6421  if ( this != &rhs )
6422  {
6423  clear();
6424  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
6425  m_operation = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_operation, {} );
6426  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
6427  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
6428  }
6429  return *this;
6430  }
6431 
6433  {
6434  return m_operation;
6435  }
6436 
6438  {
6439  if ( m_operation )
6440  {
6441  getDispatcher()->vkDestroyDeferredOperationKHR( static_cast<VkDevice>( m_device ),
6442  static_cast<VkDeferredOperationKHR>( m_operation ),
6443  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6444  }
6445  m_device = nullptr;
6446  m_operation = nullptr;
6447  m_allocator = nullptr;
6448  m_dispatcher = nullptr;
6449  }
6450 
6452  {
6453  m_device = nullptr;
6454  m_allocator = nullptr;
6455  m_dispatcher = nullptr;
6456  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_operation, nullptr );
6457  }
6458 
6460  {
6461  return m_device;
6462  }
6463 
6465  {
6466  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6467  return m_dispatcher;
6468  }
6469 
6471  {
6472  std::swap( m_device, rhs.m_device );
6473  std::swap( m_operation, rhs.m_operation );
6474  std::swap( m_allocator, rhs.m_allocator );
6475  std::swap( m_dispatcher, rhs.m_dispatcher );
6476  }
6477 
6478  //=== VK_KHR_deferred_host_operations ===
6479 
6480  VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT;
6481 
6483 
6485 
6486  private:
6487  VULKAN_HPP_NAMESPACE::Device m_device = {};
6489  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6491  };
6492 
6494  {
6495  public:
6496  using CType = VkDescriptorPool;
6497 
6501 
6502  public:
6506  : m_device( *device )
6507  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6508  , m_dispatcher( device.getDispatcher() )
6509  {
6511  device.getDispatcher()->vkCreateDescriptorPool( static_cast<VkDevice>( *device ),
6512  reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
6513  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6514  reinterpret_cast<VkDescriptorPool *>( &m_descriptorPool ) ) );
6516  {
6517  throwResultException( result, "vkCreateDescriptorPool" );
6518  }
6519  }
6520 
6522  VkDescriptorPool descriptorPool,
6524  : m_device( *device )
6525  , m_descriptorPool( descriptorPool )
6526  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6527  , m_dispatcher( device.getDispatcher() )
6528  {
6529  }
6530 
6531  DescriptorPool( std::nullptr_t ) {}
6532 
6534  {
6535  clear();
6536  }
6537 
6538  DescriptorPool() = delete;
6539  DescriptorPool( DescriptorPool const & ) = delete;
6541  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6542  , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) )
6543  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6545  {
6546  }
6547  DescriptorPool & operator=( DescriptorPool const & ) = delete;
6549  {
6550  if ( this != &rhs )
6551  {
6552  clear();
6553  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
6554  m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} );
6555  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
6556  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
6557  }
6558  return *this;
6559  }
6560 
6562  {
6563  return m_descriptorPool;
6564  }
6565 
6567  {
6568  if ( m_descriptorPool )
6569  {
6570  getDispatcher()->vkDestroyDescriptorPool( static_cast<VkDevice>( m_device ),
6571  static_cast<VkDescriptorPool>( m_descriptorPool ),
6572  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6573  }
6574  m_device = nullptr;
6575  m_descriptorPool = nullptr;
6576  m_allocator = nullptr;
6577  m_dispatcher = nullptr;
6578  }
6579 
6581  {
6582  m_device = nullptr;
6583  m_allocator = nullptr;
6584  m_dispatcher = nullptr;
6585  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorPool, nullptr );
6586  }
6587 
6589  {
6590  return m_device;
6591  }
6592 
6594  {
6595  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6596  return m_dispatcher;
6597  }
6598 
6600  {
6601  std::swap( m_device, rhs.m_device );
6602  std::swap( m_descriptorPool, rhs.m_descriptorPool );
6603  std::swap( m_allocator, rhs.m_allocator );
6604  std::swap( m_dispatcher, rhs.m_dispatcher );
6605  }
6606 
6607  //=== VK_VERSION_1_0 ===
6608 
6610 
6611  private:
6612  VULKAN_HPP_NAMESPACE::Device m_device = {};
6613  VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {};
6614  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6616  };
6617 
6619  {
6620  public:
6621  using CType = VkDescriptorSet;
6622 
6626 
6627  public:
6628  DescriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool )
6629  : m_device( *device ), m_descriptorPool( descriptorPool ), m_descriptorSet( descriptorSet ), m_dispatcher( device.getDispatcher() )
6630  {
6631  }
6632 
6633  DescriptorSet( std::nullptr_t ) {}
6634 
6636  {
6637  clear();
6638  }
6639 
6640  DescriptorSet() = delete;
6641  DescriptorSet( DescriptorSet const & ) = delete;
6643  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6644  , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) )
6645  , m_descriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) )
6647  {
6648  }
6649  DescriptorSet & operator=( DescriptorSet const & ) = delete;
6651  {
6652  if ( this != &rhs )
6653  {
6654  clear();
6655  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
6656  m_descriptorPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} );
6657  m_descriptorSet = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} );
6658  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
6659  }
6660  return *this;
6661  }
6662 
6664  {
6665  return m_descriptorSet;
6666  }
6667 
6669  {
6670  if ( m_descriptorSet )
6671  {
6672  getDispatcher()->vkFreeDescriptorSets( static_cast<VkDevice>( m_device ),
6673  static_cast<VkDescriptorPool>( m_descriptorPool ),
6674  1,
6675  reinterpret_cast<VkDescriptorSet const *>( &m_descriptorSet ) );
6676  }
6677  m_device = nullptr;
6678  m_descriptorPool = nullptr;
6679  m_descriptorSet = nullptr;
6680  m_dispatcher = nullptr;
6681  }
6682 
6684  {
6685  m_device = nullptr;
6686  m_descriptorPool = nullptr;
6687  m_dispatcher = nullptr;
6688  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorSet, nullptr );
6689  }
6690 
6692  {
6693  return m_device;
6694  }
6695 
6697  {
6698  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6699  return m_dispatcher;
6700  }
6701 
6703  {
6704  std::swap( m_device, rhs.m_device );
6705  std::swap( m_descriptorPool, rhs.m_descriptorPool );
6706  std::swap( m_descriptorSet, rhs.m_descriptorSet );
6707  std::swap( m_dispatcher, rhs.m_dispatcher );
6708  }
6709 
6710  //=== VK_VERSION_1_1 ===
6711 
6712  template <typename DataType>
6713  void updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT;
6714 
6715  //=== VK_KHR_descriptor_update_template ===
6716 
6717  template <typename DataType>
6718  void updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT;
6719 
6720  //=== VK_VALVE_descriptor_set_host_mapping ===
6721 
6722  VULKAN_HPP_NODISCARD void * getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT;
6723 
6724  private:
6725  VULKAN_HPP_NAMESPACE::Device m_device = {};
6726  VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {};
6727  VULKAN_HPP_NAMESPACE::DescriptorSet m_descriptorSet = {};
6729  };
6730 
6731  class DescriptorSets : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>
6732  {
6733  public:
6736  {
6738  std::vector<VkDescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
6740  static_cast<VkDevice>( *device ), reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), descriptorSets.data() ) );
6742  {
6743  this->reserve( allocateInfo.descriptorSetCount );
6744  for ( auto const & descriptorSet : descriptorSets )
6745  {
6746  this->emplace_back( device, descriptorSet, static_cast<VkDescriptorPool>( allocateInfo.descriptorPool ) );
6747  }
6748  }
6749  else
6750  {
6751  throwResultException( result, "vkAllocateDescriptorSets" );
6752  }
6753  }
6754 
6755  DescriptorSets( std::nullptr_t ) {}
6756 
6757  DescriptorSets() = delete;
6758  DescriptorSets( DescriptorSets const & ) = delete;
6759  DescriptorSets( DescriptorSets && rhs ) = default;
6760  DescriptorSets & operator=( DescriptorSets const & ) = delete;
6761  DescriptorSets & operator=( DescriptorSets && rhs ) = default;
6762  };
6763 
6765  {
6766  public:
6767  using CType = VkDescriptorSetLayout;
6768 
6772 
6773  public:
6777  : m_device( *device )
6778  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6779  , m_dispatcher( device.getDispatcher() )
6780  {
6782  device.getDispatcher()->vkCreateDescriptorSetLayout( static_cast<VkDevice>( *device ),
6783  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
6784  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6785  reinterpret_cast<VkDescriptorSetLayout *>( &m_descriptorSetLayout ) ) );
6787  {
6788  throwResultException( result, "vkCreateDescriptorSetLayout" );
6789  }
6790  }
6791 
6793  VkDescriptorSetLayout descriptorSetLayout,
6795  : m_device( *device )
6796  , m_descriptorSetLayout( descriptorSetLayout )
6797  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6798  , m_dispatcher( device.getDispatcher() )
6799  {
6800  }
6801 
6802  DescriptorSetLayout( std::nullptr_t ) {}
6803 
6805  {
6806  clear();
6807  }
6808 
6809  DescriptorSetLayout() = delete;
6810  DescriptorSetLayout( DescriptorSetLayout const & ) = delete;
6812  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6813  , m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) )
6814  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6816  {
6817  }
6818  DescriptorSetLayout & operator=( DescriptorSetLayout const & ) = delete;
6820  {
6821  if ( this != &rhs )
6822  {
6823  clear();
6824  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
6825  m_descriptorSetLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} );
6826  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
6827  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
6828  }
6829  return *this;
6830  }
6831 
6833  {
6834  return m_descriptorSetLayout;
6835  }
6836 
6838  {
6839  if ( m_descriptorSetLayout )
6840  {
6841  getDispatcher()->vkDestroyDescriptorSetLayout( static_cast<VkDevice>( m_device ),
6842  static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ),
6843  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6844  }
6845  m_device = nullptr;
6846  m_descriptorSetLayout = nullptr;
6847  m_allocator = nullptr;
6848  m_dispatcher = nullptr;
6849  }
6850 
6852  {
6853  m_device = nullptr;
6854  m_allocator = nullptr;
6855  m_dispatcher = nullptr;
6856  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorSetLayout, nullptr );
6857  }
6858 
6860  {
6861  return m_device;
6862  }
6863 
6865  {
6867  return m_dispatcher;
6868  }
6869 
6871  {
6872  std::swap( m_device, rhs.m_device );
6873  std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout );
6874  std::swap( m_allocator, rhs.m_allocator );
6875  std::swap( m_dispatcher, rhs.m_dispatcher );
6876  }
6877 
6878  //=== VK_EXT_descriptor_buffer ===
6879 
6881 
6882  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT;
6883 
6884  private:
6885  VULKAN_HPP_NAMESPACE::Device m_device = {};
6886  VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout = {};
6887  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6889  };
6890 
6892  {
6893  public:
6894  using CType = VkDescriptorUpdateTemplate;
6895 
6899 
6900  public:
6904  : m_device( *device )
6905  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6906  , m_dispatcher( device.getDispatcher() )
6907  {
6909  device.getDispatcher()->vkCreateDescriptorUpdateTemplate( static_cast<VkDevice>( *device ),
6910  reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
6911  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6912  reinterpret_cast<VkDescriptorUpdateTemplate *>( &m_descriptorUpdateTemplate ) ) );
6914  {
6915  throwResultException( result, "vkCreateDescriptorUpdateTemplate" );
6916  }
6917  }
6918 
6920  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
6922  : m_device( *device )
6923  , m_descriptorUpdateTemplate( descriptorUpdateTemplate )
6924  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6925  , m_dispatcher( device.getDispatcher() )
6926  {
6927  }
6928 
6929  DescriptorUpdateTemplate( std::nullptr_t ) {}
6930 
6932  {
6933  clear();
6934  }
6935 
6936  DescriptorUpdateTemplate() = delete;
6939  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6940  , m_descriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ) )
6941  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6943  {
6944  }
6947  {
6948  if ( this != &rhs )
6949  {
6950  clear();
6951  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
6952  m_descriptorUpdateTemplate = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} );
6953  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
6954  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
6955  }
6956  return *this;
6957  }
6958 
6960  {
6961  return m_descriptorUpdateTemplate;
6962  }
6963 
6965  {
6966  if ( m_descriptorUpdateTemplate )
6967  {
6968  getDispatcher()->vkDestroyDescriptorUpdateTemplate( static_cast<VkDevice>( m_device ),
6969  static_cast<VkDescriptorUpdateTemplate>( m_descriptorUpdateTemplate ),
6970  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6971  }
6972  m_device = nullptr;
6973  m_descriptorUpdateTemplate = nullptr;
6974  m_allocator = nullptr;
6975  m_dispatcher = nullptr;
6976  }
6977 
6979  {
6980  m_device = nullptr;
6981  m_allocator = nullptr;
6982  m_dispatcher = nullptr;
6983  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorUpdateTemplate, nullptr );
6984  }
6985 
6987  {
6988  return m_device;
6989  }
6990 
6992  {
6994  return m_dispatcher;
6995  }
6996 
6998  {
6999  std::swap( m_device, rhs.m_device );
7000  std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate );
7001  std::swap( m_allocator, rhs.m_allocator );
7002  std::swap( m_dispatcher, rhs.m_dispatcher );
7003  }
7004 
7005  private:
7006  VULKAN_HPP_NAMESPACE::Device m_device = {};
7007  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
7008  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7010  };
7011 
7013  {
7014  public:
7015  using CType = VkDeviceMemory;
7016 
7020 
7021  public:
7023  VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo,
7025  : m_device( *device )
7026  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7027  , m_dispatcher( device.getDispatcher() )
7028  {
7030  static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkAllocateMemory( static_cast<VkDevice>( *device ),
7031  reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
7032  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7033  reinterpret_cast<VkDeviceMemory *>( &m_memory ) ) );
7035  {
7036  throwResultException( result, "vkAllocateMemory" );
7037  }
7038  }
7039 
7041  VkDeviceMemory memory,
7043  : m_device( *device )
7044  , m_memory( memory )
7045  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7046  , m_dispatcher( device.getDispatcher() )
7047  {
7048  }
7049 
7050  DeviceMemory( std::nullptr_t ) {}
7051 
7053  {
7054  clear();
7055  }
7056 
7057  DeviceMemory() = delete;
7058  DeviceMemory( DeviceMemory const & ) = delete;
7060  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7061  , m_memory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} ) )
7062  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7064  {
7065  }
7066  DeviceMemory & operator=( DeviceMemory const & ) = delete;
7068  {
7069  if ( this != &rhs )
7070  {
7071  clear();
7072  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
7073  m_memory = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} );
7074  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
7075  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
7076  }
7077  return *this;
7078  }
7079 
7081  {
7082  return m_memory;
7083  }
7084 
7086  {
7087  if ( m_memory )
7088  {
7089  getDispatcher()->vkFreeMemory(
7090  static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7091  }
7092  m_device = nullptr;
7093  m_memory = nullptr;
7094  m_allocator = nullptr;
7095  m_dispatcher = nullptr;
7096  }
7097 
7099  {
7100  m_device = nullptr;
7101  m_allocator = nullptr;
7102  m_dispatcher = nullptr;
7104  }
7105 
7107  {
7108  return m_device;
7109  }
7110 
7112  {
7114  return m_dispatcher;
7115  }
7116 
7118  {
7119  std::swap( m_device, rhs.m_device );
7120  std::swap( m_memory, rhs.m_memory );
7121  std::swap( m_allocator, rhs.m_allocator );
7122  std::swap( m_dispatcher, rhs.m_dispatcher );
7123  }
7124 
7125  //=== VK_VERSION_1_0 ===
7126 
7130 
7131  void unmapMemory() const VULKAN_HPP_NOEXCEPT;
7132 
7134 
7135 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7136  //=== VK_NV_external_memory_win32 ===
7137 
7139 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
7140 
7141  //=== VK_EXT_pageable_device_local_memory ===
7142 
7143  void setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT;
7144 
7145  private:
7146  VULKAN_HPP_NAMESPACE::Device m_device = {};
7147  VULKAN_HPP_NAMESPACE::DeviceMemory m_memory = {};
7148  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7150  };
7151 
7153  {
7154  public:
7155  using CType = VkDisplayKHR;
7156 
7160 
7161  public:
7162  DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, int32_t drmFd, uint32_t connectorId )
7163  : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
7164  {
7166  static_cast<VkPhysicalDevice>( *physicalDevice ), drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &m_display ) ) );
7168  {
7169  throwResultException( result, "vkGetDrmDisplayEXT" );
7170  }
7171  }
7172 
7173 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
7174  DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, Display & dpy, RROutput rrOutput )
7175  : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
7176  {
7177  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( physicalDevice.getDispatcher()->vkGetRandROutputDisplayEXT(
7178  static_cast<VkPhysicalDevice>( *physicalDevice ), &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &m_display ) ) );
7180  {
7181  throwResultException( result, "vkGetRandROutputDisplayEXT" );
7182  }
7183  }
7184 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
7185 
7186 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7187  DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, uint32_t deviceRelativeId )
7188  : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
7189  {
7190  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( physicalDevice.getDispatcher()->vkGetWinrtDisplayNV(
7191  static_cast<VkPhysicalDevice>( *physicalDevice ), deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &m_display ) ) );
7193  {
7194  throwResultException( result, "vkGetWinrtDisplayNV" );
7195  }
7196  }
7197 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
7198 
7199  DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, VkDisplayKHR display )
7200  : m_physicalDevice( *physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() )
7201  {
7202  }
7203 
7204  DisplayKHR( std::nullptr_t ) {}
7205 
7207  {
7208  clear();
7209  }
7210 
7211  DisplayKHR() = delete;
7212  DisplayKHR( DisplayKHR const & ) = delete;
7214  : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
7215  , m_display( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} ) )
7217  {
7218  }
7219  DisplayKHR & operator=( DisplayKHR const & ) = delete;
7221  {
7222  if ( this != &rhs )
7223  {
7224  clear();
7225  m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
7226  m_display = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} );
7227  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
7228  }
7229  return *this;
7230  }
7231 
7233  {
7234  return m_display;
7235  }
7236 
7238  {
7239  if ( m_display )
7240  {
7241  getDispatcher()->vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) );
7242  }
7243  m_physicalDevice = nullptr;
7244  m_display = nullptr;
7245  m_dispatcher = nullptr;
7246  }
7247 
7249  {
7250  m_physicalDevice = nullptr;
7251  m_dispatcher = nullptr;
7252  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_display, nullptr );
7253  }
7254 
7256  {
7257  return m_physicalDevice;
7258  }
7259 
7261  {
7263  return m_dispatcher;
7264  }
7265 
7267  {
7268  std::swap( m_physicalDevice, rhs.m_physicalDevice );
7269  std::swap( m_display, rhs.m_display );
7270  std::swap( m_dispatcher, rhs.m_dispatcher );
7271  }
7272 
7273  //=== VK_KHR_display ===
7274 
7275  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const;
7276 
7278  createMode( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo,
7280 
7281  //=== VK_KHR_get_display_properties2 ===
7282 
7283  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const;
7284 
7285 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7286  //=== VK_NV_acquire_winrt_display ===
7287 
7288  void acquireWinrtNV() const;
7289 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
7290 
7291  private:
7292  VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {};
7293  VULKAN_HPP_NAMESPACE::DisplayKHR m_display = {};
7295  };
7296 
7297  class DisplayKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>
7298  {
7299  public:
7301  {
7303  std::vector<VkDisplayKHR> displays;
7304  uint32_t displayCount;
7306  do
7307  {
7308  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
7309  dispatcher->vkGetDisplayPlaneSupportedDisplaysKHR( static_cast<VkPhysicalDevice>( *physicalDevice ), planeIndex, &displayCount, nullptr ) );
7310  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && displayCount )
7311  {
7312  displays.resize( displayCount );
7313  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( dispatcher->vkGetDisplayPlaneSupportedDisplaysKHR(
7314  static_cast<VkPhysicalDevice>( *physicalDevice ), planeIndex, &displayCount, displays.data() ) );
7315  }
7316  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
7318  {
7319  VULKAN_HPP_ASSERT( displayCount <= displays.size() );
7320  this->reserve( displayCount );
7321  for ( auto const & displayKHR : displays )
7322  {
7323  this->emplace_back( physicalDevice, displayKHR );
7324  }
7325  }
7326  else
7327  {
7328  throwResultException( result, "vkGetDisplayPlaneSupportedDisplaysKHR" );
7329  }
7330  }
7331 
7332  DisplayKHRs( std::nullptr_t ) {}
7333 
7334  DisplayKHRs() = delete;
7335  DisplayKHRs( DisplayKHRs const & ) = delete;
7336  DisplayKHRs( DisplayKHRs && rhs ) = default;
7337  DisplayKHRs & operator=( DisplayKHRs const & ) = delete;
7338  DisplayKHRs & operator=( DisplayKHRs && rhs ) = default;
7339  };
7340 
7342  {
7343  public:
7344  using CType = VkDisplayModeKHR;
7345 
7349 
7350  public:
7354  : m_physicalDevice( display.getPhysicalDevice() ), m_dispatcher( display.getDispatcher() )
7355  {
7357  static_cast<VkPhysicalDevice>( display.getPhysicalDevice() ),
7358  static_cast<VkDisplayKHR>( *display ),
7359  reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
7360  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
7361  reinterpret_cast<VkDisplayModeKHR *>( &m_displayModeKHR ) ) );
7363  {
7364  throwResultException( result, "vkCreateDisplayModeKHR" );
7365  }
7366  }
7367 
7368  DisplayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, VkDisplayModeKHR displayModeKHR )
7369  : m_physicalDevice( display.getPhysicalDevice() ), m_displayModeKHR( displayModeKHR ), m_dispatcher( display.getDispatcher() )
7370  {
7371  }
7372 
7373  DisplayModeKHR( std::nullptr_t ) {}
7374 
7376  {
7377  clear();
7378  }
7379 
7380  DisplayModeKHR() = delete;
7381  DisplayModeKHR( DisplayModeKHR const & rhs ) : m_displayModeKHR( rhs.m_displayModeKHR ), m_dispatcher( rhs.m_dispatcher ) {}
7383  : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
7384  , m_displayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) )
7386  {
7387  }
7389  {
7390  m_displayModeKHR = rhs.m_displayModeKHR;
7391  m_dispatcher = rhs.m_dispatcher;
7392  return *this;
7393  }
7395  {
7396  if ( this != &rhs )
7397  {
7398  m_physicalDevice = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} );
7399  m_displayModeKHR = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} );
7400  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
7401  }
7402  return *this;
7403  }
7404 
7406  {
7407  return m_displayModeKHR;
7408  }
7409 
7411  {
7412  m_physicalDevice = nullptr;
7413  m_displayModeKHR = nullptr;
7414  m_dispatcher = nullptr;
7415  }
7416 
7418  {
7419  m_physicalDevice = nullptr;
7420  m_dispatcher = nullptr;
7421  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_displayModeKHR, nullptr );
7422  }
7423 
7425  {
7427  return m_dispatcher;
7428  }
7429 
7431  {
7432  std::swap( m_physicalDevice, rhs.m_physicalDevice );
7433  std::swap( m_displayModeKHR, rhs.m_displayModeKHR );
7434  std::swap( m_dispatcher, rhs.m_dispatcher );
7435  }
7436 
7437  //=== VK_KHR_display ===
7438 
7439  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR getDisplayPlaneCapabilities( uint32_t planeIndex ) const;
7440 
7441  private:
7442  VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {};
7443  VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR = {};
7445  };
7446 
7447  class Event
7448  {
7449  public:
7450  using CType = VkEvent;
7451 
7455 
7456  public:
7458  VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo,
7460  : m_device( *device )
7461  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7462  , m_dispatcher( device.getDispatcher() )
7463  {
7465  static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateEvent( static_cast<VkDevice>( *device ),
7466  reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
7467  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7468  reinterpret_cast<VkEvent *>( &m_event ) ) );
7470  {
7471  throwResultException( result, "vkCreateEvent" );
7472  }
7473  }
7474 
7476  VkEvent event,
7478  : m_device( *device )
7479  , m_event( event )
7480  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7481  , m_dispatcher( device.getDispatcher() )
7482  {
7483  }
7484 
7485  Event( std::nullptr_t ) {}
7486 
7488  {
7489  clear();
7490  }
7491 
7492  Event() = delete;
7493  Event( Event const & ) = delete;
7495  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7496  , m_event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} ) )
7497  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7499  {
7500  }
7501  Event & operator=( Event const & ) = delete;
7503  {
7504  if ( this != &rhs )
7505  {
7506  clear();
7507  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
7508  m_event = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} );
7509  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
7510  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
7511  }
7512  return *this;
7513  }
7514 
7516  {
7517  return m_event;
7518  }
7519 
7521  {
7522  if ( m_event )
7523  {
7524  getDispatcher()->vkDestroyEvent(
7525  static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7526  }
7527  m_device = nullptr;
7528  m_event = nullptr;
7529  m_allocator = nullptr;
7530  m_dispatcher = nullptr;
7531  }
7532 
7534  {
7535  m_device = nullptr;
7536  m_allocator = nullptr;
7537  m_dispatcher = nullptr;
7539  }
7540 
7542  {
7543  return m_device;
7544  }
7545 
7547  {
7549  return m_dispatcher;
7550  }
7551 
7553  {
7554  std::swap( m_device, rhs.m_device );
7555  std::swap( m_event, rhs.m_event );
7556  std::swap( m_allocator, rhs.m_allocator );
7557  std::swap( m_dispatcher, rhs.m_dispatcher );
7558  }
7559 
7560  //=== VK_VERSION_1_0 ===
7561 
7563 
7564  void set() const;
7565 
7566  void reset() const;
7567 
7568  private:
7569  VULKAN_HPP_NAMESPACE::Device m_device = {};
7570  VULKAN_HPP_NAMESPACE::Event m_event = {};
7571  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7573  };
7574 
7575  class Fence
7576  {
7577  public:
7578  using CType = VkFence;
7579 
7583 
7584  public:
7586  VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo,
7588  : m_device( *device )
7589  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7590  , m_dispatcher( device.getDispatcher() )
7591  {
7593  static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateFence( static_cast<VkDevice>( *device ),
7594  reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
7595  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7596  reinterpret_cast<VkFence *>( &m_fence ) ) );
7598  {
7599  throwResultException( result, "vkCreateFence" );
7600  }
7601  }
7602 
7604  VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo,
7606  : m_device( *device )
7607  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7608  , m_dispatcher( device.getDispatcher() )
7609  {
7611  device.getDispatcher()->vkRegisterDeviceEventEXT( static_cast<VkDevice>( *device ),
7612  reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
7613  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7614  reinterpret_cast<VkFence *>( &m_fence ) ) );
7616  {
7617  throwResultException( result, "vkRegisterDeviceEventEXT" );
7618  }
7619  }
7620 
7623  VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo,
7625  : m_device( *device )
7626  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7627  , m_dispatcher( device.getDispatcher() )
7628  {
7630  device.getDispatcher()->vkRegisterDisplayEventEXT( static_cast<VkDevice>( *device ),
7631  static_cast<VkDisplayKHR>( *display ),
7632  reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
7633  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7634  reinterpret_cast<VkFence *>( &m_fence ) ) );
7636  {
7637  throwResultException( result, "vkRegisterDisplayEventEXT" );
7638  }
7639  }
7640 
7642  VkFence fence,
7644  : m_device( *device )
7645  , m_fence( fence )
7646  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7647  , m_dispatcher( device.getDispatcher() )
7648  {
7649  }
7650 
7651  Fence( std::nullptr_t ) {}
7652 
7654  {
7655  clear();
7656  }
7657 
7658  Fence() = delete;
7659  Fence( Fence const & ) = delete;
7661  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7662  , m_fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} ) )
7663  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7665  {
7666  }
7667  Fence & operator=( Fence const & ) = delete;
7669  {
7670  if ( this != &rhs )
7671  {
7672  clear();
7673  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
7674  m_fence = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} );
7675  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
7676  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
7677  }
7678  return *this;
7679  }
7680 
7682  {
7683  return m_fence;
7684  }
7685 
7687  {
7688  if ( m_fence )
7689  {
7690  getDispatcher()->vkDestroyFence(
7691  static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7692  }
7693  m_device = nullptr;
7694  m_fence = nullptr;
7695  m_allocator = nullptr;
7696  m_dispatcher = nullptr;
7697  }
7698 
7700  {
7701  m_device = nullptr;
7702  m_allocator = nullptr;
7703  m_dispatcher = nullptr;
7705  }
7706 
7708  {
7709  return m_device;
7710  }
7711 
7713  {
7715  return m_dispatcher;
7716  }
7717 
7719  {
7720  std::swap( m_device, rhs.m_device );
7721  std::swap( m_fence, rhs.m_fence );
7722  std::swap( m_allocator, rhs.m_allocator );
7723  std::swap( m_dispatcher, rhs.m_dispatcher );
7724  }
7725 
7726  //=== VK_VERSION_1_0 ===
7727 
7729 
7730  private:
7731  VULKAN_HPP_NAMESPACE::Device m_device = {};
7732  VULKAN_HPP_NAMESPACE::Fence m_fence = {};
7733  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7735  };
7736 
7738  {
7739  public:
7740  using CType = VkFramebuffer;
7741 
7745 
7746  public:
7750  : m_device( *device )
7751  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7752  , m_dispatcher( device.getDispatcher() )
7753  {
7755  device.getDispatcher()->vkCreateFramebuffer( static_cast<VkDevice>( *device ),
7756  reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
7757  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7758  reinterpret_cast<VkFramebuffer *>( &m_framebuffer ) ) );
7760  {
7761  throwResultException( result, "vkCreateFramebuffer" );
7762  }
7763  }
7764 
7766  VkFramebuffer framebuffer,
7768  : m_device( *device )
7769  , m_framebuffer( framebuffer )
7770  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7771  , m_dispatcher( device.getDispatcher() )
7772  {
7773  }
7774 
7775  Framebuffer( std::nullptr_t ) {}
7776 
7778  {
7779  clear();
7780  }
7781 
7782  Framebuffer() = delete;
7783  Framebuffer( Framebuffer const & ) = delete;
7785  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7786  , m_framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} ) )
7787  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7789  {
7790  }
7791  Framebuffer & operator=( Framebuffer const & ) = delete;
7793  {
7794  if ( this != &rhs )
7795  {
7796  clear();
7797  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
7798  m_framebuffer = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} );
7799  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
7800  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
7801  }
7802  return *this;
7803  }
7804 
7806  {
7807  return m_framebuffer;
7808  }
7809 
7811  {
7812  if ( m_framebuffer )
7813  {
7814  getDispatcher()->vkDestroyFramebuffer(
7815  static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( m_framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7816  }
7817  m_device = nullptr;
7818  m_framebuffer = nullptr;
7819  m_allocator = nullptr;
7820  m_dispatcher = nullptr;
7821  }
7822 
7824  {
7825  m_device = nullptr;
7826  m_allocator = nullptr;
7827  m_dispatcher = nullptr;
7828  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_framebuffer, nullptr );
7829  }
7830 
7832  {
7833  return m_device;
7834  }
7835 
7837  {
7839  return m_dispatcher;
7840  }
7841 
7843  {
7844  std::swap( m_device, rhs.m_device );
7845  std::swap( m_framebuffer, rhs.m_framebuffer );
7846  std::swap( m_allocator, rhs.m_allocator );
7847  std::swap( m_dispatcher, rhs.m_dispatcher );
7848  }
7849 
7850  //=== VK_QCOM_tile_properties ===
7851 
7852  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> getTilePropertiesQCOM() const;
7853 
7854  private:
7855  VULKAN_HPP_NAMESPACE::Device m_device = {};
7856  VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer = {};
7857  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7859  };
7860 
7861  class Image
7862  {
7863  public:
7864  using CType = VkImage;
7865 
7869 
7870  public:
7872  VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo,
7874  : m_device( *device )
7875  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7876  , m_dispatcher( device.getDispatcher() )
7877  {
7879  static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateImage( static_cast<VkDevice>( *device ),
7880  reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
7881  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7882  reinterpret_cast<VkImage *>( &m_image ) ) );
7884  {
7885  throwResultException( result, "vkCreateImage" );
7886  }
7887  }
7888 
7890  VkImage image,
7892  : m_device( *device )
7893  , m_image( image )
7894  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7895  , m_dispatcher( device.getDispatcher() )
7896  {
7897  }
7898 
7899  Image( std::nullptr_t ) {}
7900 
7902  {
7903  clear();
7904  }
7905 
7906  Image() = delete;
7907  Image( Image const & ) = delete;
7909  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7910  , m_image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} ) )
7911  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7913  {
7914  }
7915  Image & operator=( Image const & ) = delete;
7917  {
7918  if ( this != &rhs )
7919  {
7920  clear();
7921  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
7922  m_image = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} );
7923  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
7924  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
7925  }
7926  return *this;
7927  }
7928 
7930  {
7931  return m_image;
7932  }
7933 
7935  {
7936  if ( m_image )
7937  {
7938  getDispatcher()->vkDestroyImage(
7939  static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7940  }
7941  m_device = nullptr;
7942  m_image = nullptr;
7943  m_allocator = nullptr;
7944  m_dispatcher = nullptr;
7945  }
7946 
7948  {
7949  m_device = nullptr;
7950  m_allocator = nullptr;
7951  m_dispatcher = nullptr;
7953  }
7954 
7956  {
7957  return m_device;
7958  }
7959 
7961  {
7963  return m_dispatcher;
7964  }
7965 
7967  {
7968  std::swap( m_device, rhs.m_device );
7969  std::swap( m_image, rhs.m_image );
7970  std::swap( m_allocator, rhs.m_allocator );
7971  std::swap( m_dispatcher, rhs.m_dispatcher );
7972  }
7973 
7974  //=== VK_VERSION_1_0 ===
7975 
7976  void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
7977 
7979 
7980  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> getSparseMemoryRequirements() const;
7981 
7983  getSubresourceLayout( const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT;
7984 
7985  //=== VK_EXT_image_drm_format_modifier ===
7986 
7987  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT getDrmFormatModifierPropertiesEXT() const;
7988 
7989  //=== VK_EXT_image_compression_control ===
7990 
7992  getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource ) const VULKAN_HPP_NOEXCEPT;
7993 
7994  template <typename X, typename Y, typename... Z>
7996  getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource ) const VULKAN_HPP_NOEXCEPT;
7997 
7998  private:
7999  VULKAN_HPP_NAMESPACE::Device m_device = {};
8000  VULKAN_HPP_NAMESPACE::Image m_image = {};
8001  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8003  };
8004 
8006  {
8007  public:
8008  using CType = VkImageView;
8009 
8013 
8014  public:
8016  VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo,
8018  : m_device( *device )
8019  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8020  , m_dispatcher( device.getDispatcher() )
8021  {
8023  static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateImageView( static_cast<VkDevice>( *device ),
8024  reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
8025  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8026  reinterpret_cast<VkImageView *>( &m_imageView ) ) );
8028  {
8029  throwResultException( result, "vkCreateImageView" );
8030  }
8031  }
8032 
8034  VkImageView imageView,
8036  : m_device( *device )
8037  , m_imageView( imageView )
8038  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8039  , m_dispatcher( device.getDispatcher() )
8040  {
8041  }
8042 
8043  ImageView( std::nullptr_t ) {}
8044 
8046  {
8047  clear();
8048  }
8049 
8050  ImageView() = delete;
8051  ImageView( ImageView const & ) = delete;
8053  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8054  , m_imageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} ) )
8055  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8057  {
8058  }
8059  ImageView & operator=( ImageView const & ) = delete;
8061  {
8062  if ( this != &rhs )
8063  {
8064  clear();
8065  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
8066  m_imageView = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} );
8067  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
8068  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
8069  }
8070  return *this;
8071  }
8072 
8074  {
8075  return m_imageView;
8076  }
8077 
8079  {
8080  if ( m_imageView )
8081  {
8082  getDispatcher()->vkDestroyImageView(
8083  static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8084  }
8085  m_device = nullptr;
8086  m_imageView = nullptr;
8087  m_allocator = nullptr;
8088  m_dispatcher = nullptr;
8089  }
8090 
8092  {
8093  m_device = nullptr;
8094  m_allocator = nullptr;
8095  m_dispatcher = nullptr;
8096  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_imageView, nullptr );
8097  }
8098 
8100  {
8101  return m_device;
8102  }
8103 
8105  {
8107  return m_dispatcher;
8108  }
8109 
8111  {
8112  std::swap( m_device, rhs.m_device );
8113  std::swap( m_imageView, rhs.m_imageView );
8114  std::swap( m_allocator, rhs.m_allocator );
8115  std::swap( m_dispatcher, rhs.m_dispatcher );
8116  }
8117 
8118  //=== VK_NVX_image_view_handle ===
8119 
8121 
8122  private:
8123  VULKAN_HPP_NAMESPACE::Device m_device = {};
8124  VULKAN_HPP_NAMESPACE::ImageView m_imageView = {};
8125  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8127  };
8128 
8130  {
8131  public:
8132  using CType = VkIndirectCommandsLayoutNV;
8133 
8137 
8138  public:
8142  : m_device( *device )
8143  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8144  , m_dispatcher( device.getDispatcher() )
8145  {
8147  device.getDispatcher()->vkCreateIndirectCommandsLayoutNV( static_cast<VkDevice>( *device ),
8148  reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ),
8149  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8150  reinterpret_cast<VkIndirectCommandsLayoutNV *>( &m_indirectCommandsLayout ) ) );
8152  {
8153  throwResultException( result, "vkCreateIndirectCommandsLayoutNV" );
8154  }
8155  }
8156 
8158  VkIndirectCommandsLayoutNV indirectCommandsLayout,
8160  : m_device( *device )
8161  , m_indirectCommandsLayout( indirectCommandsLayout )
8162  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8163  , m_dispatcher( device.getDispatcher() )
8164  {
8165  }
8166 
8167  IndirectCommandsLayoutNV( std::nullptr_t ) {}
8168 
8170  {
8171  clear();
8172  }
8173 
8174  IndirectCommandsLayoutNV() = delete;
8177  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8178  , m_indirectCommandsLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ) )
8179  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8181  {
8182  }
8185  {
8186  if ( this != &rhs )
8187  {
8188  clear();
8189  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
8190  m_indirectCommandsLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} );
8191  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
8192  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
8193  }
8194  return *this;
8195  }
8196 
8198  {
8199  return m_indirectCommandsLayout;
8200  }
8201 
8203  {
8204  if ( m_indirectCommandsLayout )
8205  {
8206  getDispatcher()->vkDestroyIndirectCommandsLayoutNV( static_cast<VkDevice>( m_device ),
8207  static_cast<VkIndirectCommandsLayoutNV>( m_indirectCommandsLayout ),
8208  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8209  }
8210  m_device = nullptr;
8211  m_indirectCommandsLayout = nullptr;
8212  m_allocator = nullptr;
8213  m_dispatcher = nullptr;
8214  }
8215 
8217  {
8218  m_device = nullptr;
8219  m_allocator = nullptr;
8220  m_dispatcher = nullptr;
8221  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_indirectCommandsLayout, nullptr );
8222  }
8223 
8225  {
8226  return m_device;
8227  }
8228 
8230  {
8232  return m_dispatcher;
8233  }
8234 
8236  {
8237  std::swap( m_device, rhs.m_device );
8238  std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout );
8239  std::swap( m_allocator, rhs.m_allocator );
8240  std::swap( m_dispatcher, rhs.m_dispatcher );
8241  }
8242 
8243  private:
8244  VULKAN_HPP_NAMESPACE::Device m_device = {};
8245  VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayout = {};
8246  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8248  };
8249 
8251  {
8252  public:
8253  using CType = VkMicromapEXT;
8254 
8258 
8259  public:
8263  : m_device( *device )
8264  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8265  , m_dispatcher( device.getDispatcher() )
8266  {
8268  device.getDispatcher()->vkCreateMicromapEXT( static_cast<VkDevice>( *device ),
8269  reinterpret_cast<const VkMicromapCreateInfoEXT *>( &createInfo ),
8270  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8271  reinterpret_cast<VkMicromapEXT *>( &m_micromap ) ) );
8273  {
8274  throwResultException( result, "vkCreateMicromapEXT" );
8275  }
8276  }
8277 
8279  VkMicromapEXT micromap,
8281  : m_device( *device )
8282  , m_micromap( micromap )
8283  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8284  , m_dispatcher( device.getDispatcher() )
8285  {
8286  }
8287 
8288  MicromapEXT( std::nullptr_t ) {}
8289 
8291  {
8292  clear();
8293  }
8294 
8295  MicromapEXT() = delete;
8296  MicromapEXT( MicromapEXT const & ) = delete;
8298  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8299  , m_micromap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_micromap, {} ) )
8300  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8302  {
8303  }
8304  MicromapEXT & operator=( MicromapEXT const & ) = delete;
8306  {
8307  if ( this != &rhs )
8308  {
8309  clear();
8310  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
8311  m_micromap = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_micromap, {} );
8312  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
8313  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
8314  }
8315  return *this;
8316  }
8317 
8319  {
8320  return m_micromap;
8321  }
8322 
8324  {
8325  if ( m_micromap )
8326  {
8327  getDispatcher()->vkDestroyMicromapEXT(
8328  static_cast<VkDevice>( m_device ), static_cast<VkMicromapEXT>( m_micromap ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8329  }
8330  m_device = nullptr;
8331  m_micromap = nullptr;
8332  m_allocator = nullptr;
8333  m_dispatcher = nullptr;
8334  }
8335 
8337  {
8338  m_device = nullptr;
8339  m_allocator = nullptr;
8340  m_dispatcher = nullptr;
8341  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_micromap, nullptr );
8342  }
8343 
8345  {
8346  return m_device;
8347  }
8348 
8350  {
8352  return m_dispatcher;
8353  }
8354 
8356  {
8357  std::swap( m_device, rhs.m_device );
8358  std::swap( m_micromap, rhs.m_micromap );
8359  std::swap( m_allocator, rhs.m_allocator );
8360  std::swap( m_dispatcher, rhs.m_dispatcher );
8361  }
8362 
8363  private:
8364  VULKAN_HPP_NAMESPACE::Device m_device = {};
8365  VULKAN_HPP_NAMESPACE::MicromapEXT m_micromap = {};
8366  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8368  };
8369 
8371  {
8372  public:
8373  using CType = VkOpticalFlowSessionNV;
8374 
8378 
8379  public:
8383  : m_device( *device )
8384  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8385  , m_dispatcher( device.getDispatcher() )
8386  {
8388  device.getDispatcher()->vkCreateOpticalFlowSessionNV( static_cast<VkDevice>( *device ),
8389  reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( &createInfo ),
8390  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8391  reinterpret_cast<VkOpticalFlowSessionNV *>( &m_session ) ) );
8393  {
8394  throwResultException( result, "vkCreateOpticalFlowSessionNV" );
8395  }
8396  }
8397 
8399  VkOpticalFlowSessionNV session,
8401  : m_device( *device )
8402  , m_session( session )
8403  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8404  , m_dispatcher( device.getDispatcher() )
8405  {
8406  }
8407 
8408  OpticalFlowSessionNV( std::nullptr_t ) {}
8409 
8411  {
8412  clear();
8413  }
8414 
8415  OpticalFlowSessionNV() = delete;
8416  OpticalFlowSessionNV( OpticalFlowSessionNV const & ) = delete;
8418  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8419  , m_session( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_session, {} ) )
8420  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8422  {
8423  }
8424  OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & ) = delete;
8426  {
8427  if ( this != &rhs )
8428  {
8429  clear();
8430  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
8431  m_session = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_session, {} );
8432  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
8433  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
8434  }
8435  return *this;
8436  }
8437 
8439  {
8440  return m_session;
8441  }
8442 
8444  {
8445  if ( m_session )
8446  {
8447  getDispatcher()->vkDestroyOpticalFlowSessionNV( static_cast<VkDevice>( m_device ),
8448  static_cast<VkOpticalFlowSessionNV>( m_session ),
8449  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8450  }
8451  m_device = nullptr;
8452  m_session = nullptr;
8453  m_allocator = nullptr;
8454  m_dispatcher = nullptr;
8455  }
8456 
8458  {
8459  m_device = nullptr;
8460  m_allocator = nullptr;
8461  m_dispatcher = nullptr;
8462  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_session, nullptr );
8463  }
8464 
8466  {
8467  return m_device;
8468  }
8469 
8471  {
8473  return m_dispatcher;
8474  }
8475 
8477  {
8478  std::swap( m_device, rhs.m_device );
8479  std::swap( m_session, rhs.m_session );
8480  std::swap( m_allocator, rhs.m_allocator );
8481  std::swap( m_dispatcher, rhs.m_dispatcher );
8482  }
8483 
8484  //=== VK_NV_optical_flow ===
8485 
8486  void bindImage( VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
8488  VULKAN_HPP_NAMESPACE::ImageLayout layout ) const;
8489 
8490  private:
8491  VULKAN_HPP_NAMESPACE::Device m_device = {};
8493  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8495  };
8496 
8498  {
8499  public:
8500  using CType = VkPerformanceConfigurationINTEL;
8501 
8505 
8506  public:
8509  : m_device( *device ), m_dispatcher( device.getDispatcher() )
8510  {
8512  device.getDispatcher()->vkAcquirePerformanceConfigurationINTEL( static_cast<VkDevice>( *device ),
8513  reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
8514  reinterpret_cast<VkPerformanceConfigurationINTEL *>( &m_configuration ) ) );
8516  {
8517  throwResultException( result, "vkAcquirePerformanceConfigurationINTEL" );
8518  }
8519  }
8520 
8521  PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkPerformanceConfigurationINTEL configuration )
8522  : m_device( *device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() )
8523  {
8524  }
8525 
8526  PerformanceConfigurationINTEL( std::nullptr_t ) {}
8527 
8529  {
8530  clear();
8531  }
8532 
8533  PerformanceConfigurationINTEL() = delete;
8536  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8537  , m_configuration( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_configuration, {} ) )
8539  {
8540  }
8543  {
8544  if ( this != &rhs )
8545  {
8546  clear();
8547  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
8548  m_configuration = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_configuration, {} );
8549  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
8550  }
8551  return *this;
8552  }
8553 
8555  {
8556  return m_configuration;
8557  }
8558 
8560  {
8561  if ( m_configuration )
8562  {
8563  getDispatcher()->vkReleasePerformanceConfigurationINTEL( static_cast<VkDevice>( m_device ),
8564  static_cast<VkPerformanceConfigurationINTEL>( m_configuration ) );
8565  }
8566  m_device = nullptr;
8567  m_configuration = nullptr;
8568  m_dispatcher = nullptr;
8569  }
8570 
8572  {
8573  m_device = nullptr;
8574  m_dispatcher = nullptr;
8575  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_configuration, nullptr );
8576  }
8577 
8579  {
8580  return m_device;
8581  }
8582 
8584  {
8586  return m_dispatcher;
8587  }
8588 
8590  {
8591  std::swap( m_device, rhs.m_device );
8592  std::swap( m_configuration, rhs.m_configuration );
8593  std::swap( m_dispatcher, rhs.m_dispatcher );
8594  }
8595 
8596  private:
8597  VULKAN_HPP_NAMESPACE::Device m_device = {};
8600  };
8601 
8603  {
8604  public:
8605  using CType = VkPipelineCache;
8606 
8610 
8611  public:
8615  : m_device( *device )
8616  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8617  , m_dispatcher( device.getDispatcher() )
8618  {
8620  device.getDispatcher()->vkCreatePipelineCache( static_cast<VkDevice>( *device ),
8621  reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
8622  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8623  reinterpret_cast<VkPipelineCache *>( &m_pipelineCache ) ) );
8625  {
8626  throwResultException( result, "vkCreatePipelineCache" );
8627  }
8628  }
8629 
8631  VkPipelineCache pipelineCache,
8633  : m_device( *device )
8634  , m_pipelineCache( pipelineCache )
8635  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8636  , m_dispatcher( device.getDispatcher() )
8637  {
8638  }
8639 
8640  PipelineCache( std::nullptr_t ) {}
8641 
8643  {
8644  clear();
8645  }
8646 
8647  PipelineCache() = delete;
8648  PipelineCache( PipelineCache const & ) = delete;
8650  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8651  , m_pipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) )
8652  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8654  {
8655  }
8656  PipelineCache & operator=( PipelineCache const & ) = delete;
8658  {
8659  if ( this != &rhs )
8660  {
8661  clear();
8662  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
8663  m_pipelineCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} );
8664  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
8665  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
8666  }
8667  return *this;
8668  }
8669 
8671  {
8672  return m_pipelineCache;
8673  }
8674 
8676  {
8677  if ( m_pipelineCache )
8678  {
8679  getDispatcher()->vkDestroyPipelineCache( static_cast<VkDevice>( m_device ),
8680  static_cast<VkPipelineCache>( m_pipelineCache ),
8681  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8682  }
8683  m_device = nullptr;
8684  m_pipelineCache = nullptr;
8685  m_allocator = nullptr;
8686  m_dispatcher = nullptr;
8687  }
8688 
8690  {
8691  m_device = nullptr;
8692  m_allocator = nullptr;
8693  m_dispatcher = nullptr;
8694  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_pipelineCache, nullptr );
8695  }
8696 
8698  {
8699  return m_device;
8700  }
8701 
8703  {
8705  return m_dispatcher;
8706  }
8707 
8709  {
8710  std::swap( m_device, rhs.m_device );
8711  std::swap( m_pipelineCache, rhs.m_pipelineCache );
8712  std::swap( m_allocator, rhs.m_allocator );
8713  std::swap( m_dispatcher, rhs.m_dispatcher );
8714  }
8715 
8716  //=== VK_VERSION_1_0 ===
8717 
8718  VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
8719 
8721 
8722  private:
8723  VULKAN_HPP_NAMESPACE::Device m_device = {};
8724  VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache = {};
8725  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8727  };
8728 
8729  class Pipeline
8730  {
8731  public:
8732  using CType = VkPipeline;
8733 
8737 
8738  public:
8743  : m_device( *device )
8744  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8745  , m_dispatcher( device.getDispatcher() )
8746  {
8747  m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>(
8748  getDispatcher()->vkCreateComputePipelines( static_cast<VkDevice>( *device ),
8749  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8750  1,
8751  reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ),
8752  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8753  reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
8754  if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
8755  ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
8756  {
8757  throwResultException( m_constructorSuccessCode, "vkCreateComputePipelines" );
8758  }
8759  }
8760 
8765  : m_device( *device )
8766  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8767  , m_dispatcher( device.getDispatcher() )
8768  {
8769  m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>(
8770  getDispatcher()->vkCreateGraphicsPipelines( static_cast<VkDevice>( *device ),
8771  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8772  1,
8773  reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
8774  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8775  reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
8776  if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
8777  ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
8778  {
8779  throwResultException( m_constructorSuccessCode, "vkCreateGraphicsPipelines" );
8780  }
8781  }
8782 
8788  : m_device( *device )
8789  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8790  , m_dispatcher( device.getDispatcher() )
8791  {
8792  m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>(
8793  getDispatcher()->vkCreateRayTracingPipelinesKHR( static_cast<VkDevice>( *device ),
8794  deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0,
8795  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8796  1,
8797  reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ),
8798  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8799  reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
8800  if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
8801  ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) &&
8802  ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) &&
8803  ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
8804  {
8805  throwResultException( m_constructorSuccessCode, "vkCreateRayTracingPipelinesKHR" );
8806  }
8807  }
8808 
8813  : m_device( *device )
8814  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8815  , m_dispatcher( device.getDispatcher() )
8816  {
8817  m_constructorSuccessCode = static_cast<VULKAN_HPP_NAMESPACE::Result>(
8818  getDispatcher()->vkCreateRayTracingPipelinesNV( static_cast<VkDevice>( *device ),
8819  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8820  1,
8821  reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
8822  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8823  reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
8824  if ( ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) &&
8825  ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
8826  {
8827  throwResultException( m_constructorSuccessCode, "vkCreateRayTracingPipelinesNV" );
8828  }
8829  }
8830 
8832  VkPipeline pipeline,
8835  : m_device( *device )
8836  , m_pipeline( pipeline )
8837  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8838  , m_constructorSuccessCode( successCode )
8839  , m_dispatcher( device.getDispatcher() )
8840  {
8841  }
8842 
8843  Pipeline( std::nullptr_t ) {}
8844 
8846  {
8847  clear();
8848  }
8849 
8850  Pipeline() = delete;
8851  Pipeline( Pipeline const & ) = delete;
8853  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8854  , m_pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} ) )
8855  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8856  , m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) )
8858  {
8859  }
8860  Pipeline & operator=( Pipeline const & ) = delete;
8862  {
8863  if ( this != &rhs )
8864  {
8865  clear();
8866  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
8867  m_pipeline = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} );
8868  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
8869  m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} );
8870  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
8871  }
8872  return *this;
8873  }
8874 
8876  {
8877  return m_pipeline;
8878  }
8879 
8881  {
8882  if ( m_pipeline )
8883  {
8884  getDispatcher()->vkDestroyPipeline(
8885  static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8886  }
8887  m_device = nullptr;
8888  m_pipeline = nullptr;
8889  m_allocator = nullptr;
8890  m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;
8891  m_dispatcher = nullptr;
8892  }
8893 
8895  {
8896  m_device = nullptr;
8897  m_allocator = nullptr;
8898  m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;
8899  m_dispatcher = nullptr;
8900  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_pipeline, nullptr );
8901  }
8902 
8904  {
8905  return m_constructorSuccessCode;
8906  }
8907 
8909  {
8910  return m_device;
8911  }
8912 
8914  {
8916  return m_dispatcher;
8917  }
8918 
8920  {
8921  std::swap( m_device, rhs.m_device );
8922  std::swap( m_pipeline, rhs.m_pipeline );
8923  std::swap( m_allocator, rhs.m_allocator );
8924  std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );
8925  std::swap( m_dispatcher, rhs.m_dispatcher );
8926  }
8927 
8928  //=== VK_AMD_shader_info ===
8929 
8930  VULKAN_HPP_NODISCARD std::vector<uint8_t> getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
8931  VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType ) const;
8932 
8933  //=== VK_NV_ray_tracing ===
8934 
8935  template <typename DataType>
8936  VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
8937 
8938  template <typename DataType>
8939  VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const;
8940 
8941  void compileDeferredNV( uint32_t shader ) const;
8942 
8943  //=== VK_KHR_ray_tracing_pipeline ===
8944 
8945  template <typename DataType>
8946  VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
8947 
8948  template <typename DataType>
8949  VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const;
8950 
8951  template <typename DataType>
8952  VULKAN_HPP_NODISCARD std::vector<DataType>
8953  getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
8954 
8955  template <typename DataType>
8956  VULKAN_HPP_NODISCARD DataType getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const;
8957 
8959  getRayTracingShaderGroupStackSizeKHR( uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT;
8960 
8961  private:
8962  VULKAN_HPP_NAMESPACE::Device m_device = {};
8963  VULKAN_HPP_NAMESPACE::Pipeline m_pipeline = {};
8964  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8967  };
8968 
8969  class Pipelines : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>
8970  {
8971  public:
8976  {
8978  std::vector<VkPipeline> pipelines( createInfos.size() );
8980  static_cast<VkDevice>( *device ),
8981  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8982  createInfos.size(),
8983  reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ),
8984  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
8985  pipelines.data() ) );
8987  {
8988  this->reserve( createInfos.size() );
8989  for ( auto const & pipeline : pipelines )
8990  {
8991  this->emplace_back( device, pipeline, allocator, result );
8992  }
8993  }
8994  else
8995  {
8996  throwResultException( result, "vkCreateComputePipelines" );
8997  }
8998  }
8999 
9004  {
9006  std::vector<VkPipeline> pipelines( createInfos.size() );
9008  static_cast<VkDevice>( *device ),
9009  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
9010  createInfos.size(),
9011  reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
9012  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
9013  pipelines.data() ) );
9015  {
9016  this->reserve( createInfos.size() );
9017  for ( auto const & pipeline : pipelines )
9018  {
9019  this->emplace_back( device, pipeline, allocator, result );
9020  }
9021  }
9022  else
9023  {
9024  throwResultException( result, "vkCreateGraphicsPipelines" );
9025  }
9026  }
9027 
9033  {
9035  std::vector<VkPipeline> pipelines( createInfos.size() );
9037  static_cast<VkDevice>( *device ),
9038  deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0,
9039  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
9040  createInfos.size(),
9041  reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ),
9042  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
9043  pipelines.data() ) );
9046  {
9047  this->reserve( createInfos.size() );
9048  for ( auto const & pipeline : pipelines )
9049  {
9050  this->emplace_back( device, pipeline, allocator, result );
9051  }
9052  }
9053  else
9054  {
9055  throwResultException( result, "vkCreateRayTracingPipelinesKHR" );
9056  }
9057  }
9058 
9063  {
9065  std::vector<VkPipeline> pipelines( createInfos.size() );
9067  static_cast<VkDevice>( *device ),
9068  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
9069  createInfos.size(),
9070  reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
9071  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
9072  pipelines.data() ) );
9074  {
9075  this->reserve( createInfos.size() );
9076  for ( auto const & pipeline : pipelines )
9077  {
9078  this->emplace_back( device, pipeline, allocator, result );
9079  }
9080  }
9081  else
9082  {
9083  throwResultException( result, "vkCreateRayTracingPipelinesNV" );
9084  }
9085  }
9086 
9087  Pipelines( std::nullptr_t ) {}
9088 
9089  Pipelines() = delete;
9090  Pipelines( Pipelines const & ) = delete;
9091  Pipelines( Pipelines && rhs ) = default;
9092  Pipelines & operator=( Pipelines const & ) = delete;
9093  Pipelines & operator=( Pipelines && rhs ) = default;
9094  };
9095 
9097  {
9098  public:
9099  using CType = VkPipelineLayout;
9100 
9104 
9105  public:
9109  : m_device( *device )
9110  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9111  , m_dispatcher( device.getDispatcher() )
9112  {
9114  device.getDispatcher()->vkCreatePipelineLayout( static_cast<VkDevice>( *device ),
9115  reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
9116  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9117  reinterpret_cast<VkPipelineLayout *>( &m_pipelineLayout ) ) );
9119  {
9120  throwResultException( result, "vkCreatePipelineLayout" );
9121  }
9122  }
9123 
9125  VkPipelineLayout pipelineLayout,
9127  : m_device( *device )
9128  , m_pipelineLayout( pipelineLayout )
9129  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9130  , m_dispatcher( device.getDispatcher() )
9131  {
9132  }
9133 
9134  PipelineLayout( std::nullptr_t ) {}
9135 
9137  {
9138  clear();
9139  }
9140 
9141  PipelineLayout() = delete;
9142  PipelineLayout( PipelineLayout const & ) = delete;
9144  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9145  , m_pipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) )
9146  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9148  {
9149  }
9150  PipelineLayout & operator=( PipelineLayout const & ) = delete;
9152  {
9153  if ( this != &rhs )
9154  {
9155  clear();
9156  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
9157  m_pipelineLayout = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} );
9158  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
9159  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
9160  }
9161  return *this;
9162  }
9163 
9165  {
9166  return m_pipelineLayout;
9167  }
9168 
9170  {
9171  if ( m_pipelineLayout )
9172  {
9173  getDispatcher()->vkDestroyPipelineLayout( static_cast<VkDevice>( m_device ),
9174  static_cast<VkPipelineLayout>( m_pipelineLayout ),
9175  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9176  }
9177  m_device = nullptr;
9178  m_pipelineLayout = nullptr;
9179  m_allocator = nullptr;
9180  m_dispatcher = nullptr;
9181  }
9182 
9184  {
9185  m_device = nullptr;
9186  m_allocator = nullptr;
9187  m_dispatcher = nullptr;
9188  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_pipelineLayout, nullptr );
9189  }
9190 
9192  {
9193  return m_device;
9194  }
9195 
9197  {
9199  return m_dispatcher;
9200  }
9201 
9203  {
9204  std::swap( m_device, rhs.m_device );
9205  std::swap( m_pipelineLayout, rhs.m_pipelineLayout );
9206  std::swap( m_allocator, rhs.m_allocator );
9207  std::swap( m_dispatcher, rhs.m_dispatcher );
9208  }
9209 
9210  private:
9211  VULKAN_HPP_NAMESPACE::Device m_device = {};
9212  VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout = {};
9213  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9215  };
9216 
9218  {
9219  public:
9220  using CType = VkPrivateDataSlot;
9221 
9225 
9226  public:
9230  : m_device( *device )
9231  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9232  , m_dispatcher( device.getDispatcher() )
9233  {
9235  device.getDispatcher()->vkCreatePrivateDataSlot( static_cast<VkDevice>( *device ),
9236  reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ),
9237  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9238  reinterpret_cast<VkPrivateDataSlot *>( &m_privateDataSlot ) ) );
9240  {
9241  throwResultException( result, "vkCreatePrivateDataSlot" );
9242  }
9243  }
9244 
9246  VkPrivateDataSlot privateDataSlot,
9248  : m_device( *device )
9249  , m_privateDataSlot( privateDataSlot )
9250  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9251  , m_dispatcher( device.getDispatcher() )
9252  {
9253  }
9254 
9255  PrivateDataSlot( std::nullptr_t ) {}
9256 
9258  {
9259  clear();
9260  }
9261 
9262  PrivateDataSlot() = delete;
9263  PrivateDataSlot( PrivateDataSlot const & ) = delete;
9265  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9266  , m_privateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) )
9267  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9269  {
9270  }
9271  PrivateDataSlot & operator=( PrivateDataSlot const & ) = delete;
9273  {
9274  if ( this != &rhs )
9275  {
9276  clear();
9277  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
9278  m_privateDataSlot = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} );
9279  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
9280  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
9281  }
9282  return *this;
9283  }
9284 
9286  {
9287  return m_privateDataSlot;
9288  }
9289 
9291  {
9292  if ( m_privateDataSlot )
9293  {
9294  getDispatcher()->vkDestroyPrivateDataSlot( static_cast<VkDevice>( m_device ),
9295  static_cast<VkPrivateDataSlot>( m_privateDataSlot ),
9296  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9297  }
9298  m_device = nullptr;
9299  m_privateDataSlot = nullptr;
9300  m_allocator = nullptr;
9301  m_dispatcher = nullptr;
9302  }
9303 
9305  {
9306  m_device = nullptr;
9307  m_allocator = nullptr;
9308  m_dispatcher = nullptr;
9309  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_privateDataSlot, nullptr );
9310  }
9311 
9313  {
9314  return m_device;
9315  }
9316 
9318  {
9320  return m_dispatcher;
9321  }
9322 
9324  {
9325  std::swap( m_device, rhs.m_device );
9326  std::swap( m_privateDataSlot, rhs.m_privateDataSlot );
9327  std::swap( m_allocator, rhs.m_allocator );
9328  std::swap( m_dispatcher, rhs.m_dispatcher );
9329  }
9330 
9331  private:
9332  VULKAN_HPP_NAMESPACE::Device m_device = {};
9333  VULKAN_HPP_NAMESPACE::PrivateDataSlot m_privateDataSlot = {};
9334  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9336  };
9337 
9339  {
9340  public:
9341  using CType = VkQueryPool;
9342 
9346 
9347  public:
9349  VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo,
9351  : m_device( *device )
9352  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9353  , m_dispatcher( device.getDispatcher() )
9354  {
9356  static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateQueryPool( static_cast<VkDevice>( *device ),
9357  reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
9358  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9359  reinterpret_cast<VkQueryPool *>( &m_queryPool ) ) );
9361  {
9362  throwResultException( result, "vkCreateQueryPool" );
9363  }
9364  }
9365 
9367  VkQueryPool queryPool,
9369  : m_device( *device )
9370  , m_queryPool( queryPool )
9371  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9372  , m_dispatcher( device.getDispatcher() )
9373  {
9374  }
9375 
9376  QueryPool( std::nullptr_t ) {}
9377 
9379  {
9380  clear();
9381  }
9382 
9383  QueryPool() = delete;
9384  QueryPool( QueryPool const & ) = delete;
9386  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9387  , m_queryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} ) )
9388  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9390  {
9391  }
9392  QueryPool & operator=( QueryPool const & ) = delete;
9394  {
9395  if ( this != &rhs )
9396  {
9397  clear();
9398  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
9399  m_queryPool = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} );
9400  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
9401  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
9402  }
9403  return *this;
9404  }
9405 
9407  {
9408  return m_queryPool;
9409  }
9410 
9412  {
9413  if ( m_queryPool )
9414  {
9415  getDispatcher()->vkDestroyQueryPool(
9416  static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9417  }
9418  m_device = nullptr;
9419  m_queryPool = nullptr;
9420  m_allocator = nullptr;
9421  m_dispatcher = nullptr;
9422  }
9423 
9425  {
9426  m_device = nullptr;
9427  m_allocator = nullptr;
9428  m_dispatcher = nullptr;
9429  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_queryPool, nullptr );
9430  }
9431 
9433  {
9434  return m_device;
9435  }
9436 
9438  {
9440  return m_dispatcher;
9441  }
9442 
9444  {
9445  std::swap( m_device, rhs.m_device );
9446  std::swap( m_queryPool, rhs.m_queryPool );
9447  std::swap( m_allocator, rhs.m_allocator );
9448  std::swap( m_dispatcher, rhs.m_dispatcher );
9449  }
9450 
9451  //=== VK_VERSION_1_0 ===
9452 
9453  template <typename DataType>
9454  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>>
9455  getResults( uint32_t firstQuery,
9456  uint32_t queryCount,
9457  size_t dataSize,
9460 
9461  template <typename DataType>
9462  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, DataType>
9463  getResult( uint32_t firstQuery,
9464  uint32_t queryCount,
9467 
9468  //=== VK_VERSION_1_2 ===
9469 
9470  void reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT;
9471 
9472  //=== VK_EXT_host_query_reset ===
9473 
9474  void resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT;
9475 
9476  private:
9477  VULKAN_HPP_NAMESPACE::Device m_device = {};
9478  VULKAN_HPP_NAMESPACE::QueryPool m_queryPool = {};
9479  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9481  };
9482 
9483  class Queue
9484  {
9485  public:
9486  using CType = VkQueue;
9487 
9491 
9492  public:
9493  Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, uint32_t queueFamilyIndex, uint32_t queueIndex )
9494  : m_dispatcher( device.getDispatcher() )
9495  {
9496  getDispatcher()->vkGetDeviceQueue( static_cast<VkDevice>( *device ), queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &m_queue ) );
9497  }
9498 
9500  : m_dispatcher( device.getDispatcher() )
9501  {
9502  getDispatcher()->vkGetDeviceQueue2(
9503  static_cast<VkDevice>( *device ), reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &m_queue ) );
9504  }
9505 
9506  Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkQueue queue ) : m_queue( queue ), m_dispatcher( device.getDispatcher() )
9507  {
9508  }
9509 
9510  Queue( std::nullptr_t ) {}
9511 
9513  {
9514  clear();
9515  }
9516 
9517  Queue() = delete;
9518  Queue( Queue const & rhs ) : m_queue( rhs.m_queue ), m_dispatcher( rhs.m_dispatcher ) {}
9520  : m_queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ) )
9522  {
9523  }
9524  Queue & operator=( Queue const & rhs )
9525  {
9526  m_queue = rhs.m_queue;
9527  m_dispatcher = rhs.m_dispatcher;
9528  return *this;
9529  }
9531  {
9532  if ( this != &rhs )
9533  {
9534  m_queue = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} );
9535  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
9536  }
9537  return *this;
9538  }
9539 
9541  {
9542  return m_queue;
9543  }
9544 
9546  {
9547  m_queue = nullptr;
9548  m_dispatcher = nullptr;
9549  }
9550 
9552  {
9553  m_dispatcher = nullptr;
9555  }
9556 
9558  {
9560  return m_dispatcher;
9561  }
9562 
9564  {
9565  std::swap( m_queue, rhs.m_queue );
9566  std::swap( m_dispatcher, rhs.m_dispatcher );
9567  }
9568 
9569  //=== VK_VERSION_1_0 ===
9570 
9573 
9574  void waitIdle() const;
9575 
9578 
9579  //=== VK_VERSION_1_3 ===
9580 
9583 
9584  //=== VK_KHR_swapchain ===
9585 
9587 
9588  //=== VK_EXT_debug_utils ===
9589 
9590  void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
9591 
9592  void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT;
9593 
9594  void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
9595 
9596  //=== VK_NV_device_diagnostic_checkpoints ===
9597 
9598  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> getCheckpointDataNV() const;
9599 
9600  //=== VK_INTEL_performance_query ===
9601 
9602  void setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const;
9603 
9604  //=== VK_KHR_synchronization2 ===
9605 
9606  void submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
9608 
9609  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> getCheckpointData2NV() const;
9610 
9611  private:
9612  VULKAN_HPP_NAMESPACE::Queue m_queue = {};
9614  };
9615 
9617  {
9618  public:
9619  using CType = VkRenderPass;
9620 
9624 
9625  public:
9627  VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo,
9629  : m_device( *device )
9630  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9631  , m_dispatcher( device.getDispatcher() )
9632  {
9634  device.getDispatcher()->vkCreateRenderPass( static_cast<VkDevice>( *device ),
9635  reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
9636  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9637  reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
9639  {
9640  throwResultException( result, "vkCreateRenderPass" );
9641  }
9642  }
9643 
9647  : m_device( *device )
9648  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9649  , m_dispatcher( device.getDispatcher() )
9650  {
9652  device.getDispatcher()->vkCreateRenderPass2( static_cast<VkDevice>( *device ),
9653  reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
9654  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9655  reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
9657  {
9658  throwResultException( result, "vkCreateRenderPass2" );
9659  }
9660  }
9661 
9663  VkRenderPass renderPass,
9665  : m_device( *device )
9666  , m_renderPass( renderPass )
9667  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9668  , m_dispatcher( device.getDispatcher() )
9669  {
9670  }
9671 
9672  RenderPass( std::nullptr_t ) {}
9673 
9675  {
9676  clear();
9677  }
9678 
9679  RenderPass() = delete;
9680  RenderPass( RenderPass const & ) = delete;
9682  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9683  , m_renderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} ) )
9684  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9686  {
9687  }
9688  RenderPass & operator=( RenderPass const & ) = delete;
9690  {
9691  if ( this != &rhs )
9692  {
9693  clear();
9694  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
9695  m_renderPass = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} );
9696  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
9697  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
9698  }
9699  return *this;
9700  }
9701 
9703  {
9704  return m_renderPass;
9705  }
9706 
9708  {
9709  if ( m_renderPass )
9710  {
9711  getDispatcher()->vkDestroyRenderPass(
9712  static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9713  }
9714  m_device = nullptr;
9715  m_renderPass = nullptr;
9716  m_allocator = nullptr;
9717  m_dispatcher = nullptr;
9718  }
9719 
9721  {
9722  m_device = nullptr;
9723  m_allocator = nullptr;
9724  m_dispatcher = nullptr;
9725  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_renderPass, nullptr );
9726  }
9727 
9729  {
9730  return m_device;
9731  }
9732 
9734  {
9736  return m_dispatcher;
9737  }
9738 
9740  {
9741  std::swap( m_device, rhs.m_device );
9742  std::swap( m_renderPass, rhs.m_renderPass );
9743  std::swap( m_allocator, rhs.m_allocator );
9744  std::swap( m_dispatcher, rhs.m_dispatcher );
9745  }
9746 
9747  //=== VK_VERSION_1_0 ===
9748 
9750 
9751  //=== VK_HUAWEI_subpass_shading ===
9752 
9753  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D> getSubpassShadingMaxWorkgroupSizeHUAWEI() const;
9754 
9755  private:
9756  VULKAN_HPP_NAMESPACE::Device m_device = {};
9757  VULKAN_HPP_NAMESPACE::RenderPass m_renderPass = {};
9758  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9760  };
9761 
9762  class Sampler
9763  {
9764  public:
9765  using CType = VkSampler;
9766 
9770 
9771  public:
9773  VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo,
9775  : m_device( *device )
9776  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9777  , m_dispatcher( device.getDispatcher() )
9778  {
9780  static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateSampler( static_cast<VkDevice>( *device ),
9781  reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
9782  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9783  reinterpret_cast<VkSampler *>( &m_sampler ) ) );
9785  {
9786  throwResultException( result, "vkCreateSampler" );
9787  }
9788  }
9789 
9791  VkSampler sampler,
9793  : m_device( *device )
9794  , m_sampler( sampler )
9795  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9796  , m_dispatcher( device.getDispatcher() )
9797  {
9798  }
9799 
9800  Sampler( std::nullptr_t ) {}
9801 
9803  {
9804  clear();
9805  }
9806 
9807  Sampler() = delete;
9808  Sampler( Sampler const & ) = delete;
9810  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9811  , m_sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} ) )
9812  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9814  {
9815  }
9816  Sampler & operator=( Sampler const & ) = delete;
9818  {
9819  if ( this != &rhs )
9820  {
9821  clear();
9822  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
9823  m_sampler = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} );
9824  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
9825  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
9826  }
9827  return *this;
9828  }
9829 
9831  {
9832  return m_sampler;
9833  }
9834 
9836  {
9837  if ( m_sampler )
9838  {
9839  getDispatcher()->vkDestroySampler(
9840  static_cast<VkDevice>( m_device ), static_cast<VkSampler>( m_sampler ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9841  }
9842  m_device = nullptr;
9843  m_sampler = nullptr;
9844  m_allocator = nullptr;
9845  m_dispatcher = nullptr;
9846  }
9847 
9849  {
9850  m_device = nullptr;
9851  m_allocator = nullptr;
9852  m_dispatcher = nullptr;
9853  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_sampler, nullptr );
9854  }
9855 
9857  {
9858  return m_device;
9859  }
9860 
9862  {
9864  return m_dispatcher;
9865  }
9866 
9868  {
9869  std::swap( m_device, rhs.m_device );
9870  std::swap( m_sampler, rhs.m_sampler );
9871  std::swap( m_allocator, rhs.m_allocator );
9872  std::swap( m_dispatcher, rhs.m_dispatcher );
9873  }
9874 
9875  private:
9876  VULKAN_HPP_NAMESPACE::Device m_device = {};
9877  VULKAN_HPP_NAMESPACE::Sampler m_sampler = {};
9878  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9880  };
9881 
9883  {
9884  public:
9885  using CType = VkSamplerYcbcrConversion;
9886 
9890 
9891  public:
9895  : m_device( *device )
9896  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9897  , m_dispatcher( device.getDispatcher() )
9898  {
9900  device.getDispatcher()->vkCreateSamplerYcbcrConversion( static_cast<VkDevice>( *device ),
9901  reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
9902  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9903  reinterpret_cast<VkSamplerYcbcrConversion *>( &m_ycbcrConversion ) ) );
9905  {
9906  throwResultException( result, "vkCreateSamplerYcbcrConversion" );
9907  }
9908  }
9909 
9911  VkSamplerYcbcrConversion ycbcrConversion,
9913  : m_device( *device )
9914  , m_ycbcrConversion( ycbcrConversion )
9915  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9916  , m_dispatcher( device.getDispatcher() )
9917  {
9918  }
9919 
9920  SamplerYcbcrConversion( std::nullptr_t ) {}
9921 
9923  {
9924  clear();
9925  }
9926 
9927  SamplerYcbcrConversion() = delete;
9928  SamplerYcbcrConversion( SamplerYcbcrConversion const & ) = delete;
9930  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9931  , m_ycbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ) )
9932  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9934  {
9935  }
9938  {
9939  if ( this != &rhs )
9940  {
9941  clear();
9942  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
9943  m_ycbcrConversion = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} );
9944  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
9945  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
9946  }
9947  return *this;
9948  }
9949 
9951  {
9952  return m_ycbcrConversion;
9953  }
9954 
9956  {
9957  if ( m_ycbcrConversion )
9958  {
9959  getDispatcher()->vkDestroySamplerYcbcrConversion( static_cast<VkDevice>( m_device ),
9960  static_cast<VkSamplerYcbcrConversion>( m_ycbcrConversion ),
9961  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9962  }
9963  m_device = nullptr;
9964  m_ycbcrConversion = nullptr;
9965  m_allocator = nullptr;
9966  m_dispatcher = nullptr;
9967  }
9968 
9970  {
9971  m_device = nullptr;
9972  m_allocator = nullptr;
9973  m_dispatcher = nullptr;
9974  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_ycbcrConversion, nullptr );
9975  }
9976 
9978  {
9979  return m_device;
9980  }
9981 
9983  {
9985  return m_dispatcher;
9986  }
9987 
9989  {
9990  std::swap( m_device, rhs.m_device );
9991  std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion );
9992  std::swap( m_allocator, rhs.m_allocator );
9993  std::swap( m_dispatcher, rhs.m_dispatcher );
9994  }
9995 
9996  private:
9997  VULKAN_HPP_NAMESPACE::Device m_device = {};
9998  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_ycbcrConversion = {};
9999  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10001  };
10002 
10004  {
10005  public:
10006  using CType = VkSemaphore;
10007 
10011 
10012  public:
10014  VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo,
10016  : m_device( *device )
10017  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10018  , m_dispatcher( device.getDispatcher() )
10019  {
10021  static_cast<VULKAN_HPP_NAMESPACE::Result>( device.getDispatcher()->vkCreateSemaphore( static_cast<VkDevice>( *device ),
10022  reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
10023  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10024  reinterpret_cast<VkSemaphore *>( &m_semaphore ) ) );
10026  {
10027  throwResultException( result, "vkCreateSemaphore" );
10028  }
10029  }
10030 
10032  VkSemaphore semaphore,
10034  : m_device( *device )
10035  , m_semaphore( semaphore )
10036  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10037  , m_dispatcher( device.getDispatcher() )
10038  {
10039  }
10040 
10041  Semaphore( std::nullptr_t ) {}
10042 
10044  {
10045  clear();
10046  }
10047 
10048  Semaphore() = delete;
10049  Semaphore( Semaphore const & ) = delete;
10051  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10052  , m_semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} ) )
10053  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10055  {
10056  }
10057  Semaphore & operator=( Semaphore const & ) = delete;
10059  {
10060  if ( this != &rhs )
10061  {
10062  clear();
10063  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
10064  m_semaphore = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} );
10065  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
10066  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
10067  }
10068  return *this;
10069  }
10070 
10072  {
10073  return m_semaphore;
10074  }
10075 
10077  {
10078  if ( m_semaphore )
10079  {
10080  getDispatcher()->vkDestroySemaphore(
10081  static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10082  }
10083  m_device = nullptr;
10084  m_semaphore = nullptr;
10085  m_allocator = nullptr;
10086  m_dispatcher = nullptr;
10087  }
10088 
10090  {
10091  m_device = nullptr;
10092  m_allocator = nullptr;
10093  m_dispatcher = nullptr;
10094  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_semaphore, nullptr );
10095  }
10096 
10098  {
10099  return m_device;
10100  }
10101 
10103  {
10105  return m_dispatcher;
10106  }
10107 
10109  {
10110  std::swap( m_device, rhs.m_device );
10111  std::swap( m_semaphore, rhs.m_semaphore );
10112  std::swap( m_allocator, rhs.m_allocator );
10113  std::swap( m_dispatcher, rhs.m_dispatcher );
10114  }
10115 
10116  //=== VK_VERSION_1_2 ===
10117 
10118  VULKAN_HPP_NODISCARD uint64_t getCounterValue() const;
10119 
10120  //=== VK_KHR_timeline_semaphore ===
10121 
10122  VULKAN_HPP_NODISCARD uint64_t getCounterValueKHR() const;
10123 
10124  private:
10125  VULKAN_HPP_NAMESPACE::Device m_device = {};
10126  VULKAN_HPP_NAMESPACE::Semaphore m_semaphore = {};
10127  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10129  };
10130 
10132  {
10133  public:
10134  using CType = VkShaderModule;
10135 
10139 
10140  public:
10144  : m_device( *device )
10145  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10146  , m_dispatcher( device.getDispatcher() )
10147  {
10149  device.getDispatcher()->vkCreateShaderModule( static_cast<VkDevice>( *device ),
10150  reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
10151  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10152  reinterpret_cast<VkShaderModule *>( &m_shaderModule ) ) );
10154  {
10155  throwResultException( result, "vkCreateShaderModule" );
10156  }
10157  }
10158 
10160  VkShaderModule shaderModule,
10162  : m_device( *device )
10163  , m_shaderModule( shaderModule )
10164  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10165  , m_dispatcher( device.getDispatcher() )
10166  {
10167  }
10168 
10169  ShaderModule( std::nullptr_t ) {}
10170 
10172  {
10173  clear();
10174  }
10175 
10176  ShaderModule() = delete;
10177  ShaderModule( ShaderModule const & ) = delete;
10179  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10180  , m_shaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} ) )
10181  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10183  {
10184  }
10185  ShaderModule & operator=( ShaderModule const & ) = delete;
10187  {
10188  if ( this != &rhs )
10189  {
10190  clear();
10191  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
10192  m_shaderModule = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} );
10193  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
10194  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
10195  }
10196  return *this;
10197  }
10198 
10200  {
10201  return m_shaderModule;
10202  }
10203 
10205  {
10206  if ( m_shaderModule )
10207  {
10208  getDispatcher()->vkDestroyShaderModule(
10209  static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( m_shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10210  }
10211  m_device = nullptr;
10212  m_shaderModule = nullptr;
10213  m_allocator = nullptr;
10214  m_dispatcher = nullptr;
10215  }
10216 
10218  {
10219  m_device = nullptr;
10220  m_allocator = nullptr;
10221  m_dispatcher = nullptr;
10222  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_shaderModule, nullptr );
10223  }
10224 
10226  {
10227  return m_device;
10228  }
10229 
10231  {
10233  return m_dispatcher;
10234  }
10235 
10237  {
10238  std::swap( m_device, rhs.m_device );
10239  std::swap( m_shaderModule, rhs.m_shaderModule );
10240  std::swap( m_allocator, rhs.m_allocator );
10241  std::swap( m_dispatcher, rhs.m_dispatcher );
10242  }
10243 
10244  //=== VK_EXT_shader_module_identifier ===
10245 
10247 
10248  private:
10249  VULKAN_HPP_NAMESPACE::Device m_device = {};
10250  VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule = {};
10251  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10253  };
10254 
10256  {
10257  public:
10258  using CType = VkSurfaceKHR;
10259 
10263 
10264  public:
10265 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
10267  VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo,
10269  : m_instance( *instance )
10270  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10271  , m_dispatcher( instance.getDispatcher() )
10272  {
10274  instance.getDispatcher()->vkCreateAndroidSurfaceKHR( static_cast<VkInstance>( *instance ),
10275  reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
10276  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10277  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10279  {
10280  throwResultException( result, "vkCreateAndroidSurfaceKHR" );
10281  }
10282  }
10283 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
10284 
10285 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
10287  VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo,
10289  : m_instance( *instance )
10290  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10291  , m_dispatcher( instance.getDispatcher() )
10292  {
10294  instance.getDispatcher()->vkCreateDirectFBSurfaceEXT( static_cast<VkInstance>( *instance ),
10295  reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
10296  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10297  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10299  {
10300  throwResultException( result, "vkCreateDirectFBSurfaceEXT" );
10301  }
10302  }
10303 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
10304 
10308  : m_instance( *instance )
10309  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10310  , m_dispatcher( instance.getDispatcher() )
10311  {
10313  instance.getDispatcher()->vkCreateDisplayPlaneSurfaceKHR( static_cast<VkInstance>( *instance ),
10314  reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
10315  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10316  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10318  {
10319  throwResultException( result, "vkCreateDisplayPlaneSurfaceKHR" );
10320  }
10321  }
10322 
10326  : m_instance( *instance )
10327  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10328  , m_dispatcher( instance.getDispatcher() )
10329  {
10331  instance.getDispatcher()->vkCreateHeadlessSurfaceEXT( static_cast<VkInstance>( *instance ),
10332  reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
10333  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10334  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10336  {
10337  throwResultException( result, "vkCreateHeadlessSurfaceEXT" );
10338  }
10339  }
10340 
10341 # if defined( VK_USE_PLATFORM_IOS_MVK )
10343  VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo,
10345  : m_instance( *instance )
10346  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10347  , m_dispatcher( instance.getDispatcher() )
10348  {
10350  instance.getDispatcher()->vkCreateIOSSurfaceMVK( static_cast<VkInstance>( *instance ),
10351  reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
10352  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10353  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10355  {
10356  throwResultException( result, "vkCreateIOSSurfaceMVK" );
10357  }
10358  }
10359 # endif /*VK_USE_PLATFORM_IOS_MVK*/
10360 
10361 # if defined( VK_USE_PLATFORM_FUCHSIA )
10362  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10363  VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo,
10365  : m_instance( *instance )
10366  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10367  , m_dispatcher( instance.getDispatcher() )
10368  {
10370  instance.getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA( static_cast<VkInstance>( *instance ),
10371  reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
10372  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10373  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10375  {
10376  throwResultException( result, "vkCreateImagePipeSurfaceFUCHSIA" );
10377  }
10378  }
10379 # endif /*VK_USE_PLATFORM_FUCHSIA*/
10380 
10381 # if defined( VK_USE_PLATFORM_MACOS_MVK )
10382  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10383  VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo,
10385  : m_instance( *instance )
10386  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10387  , m_dispatcher( instance.getDispatcher() )
10388  {
10390  instance.getDispatcher()->vkCreateMacOSSurfaceMVK( static_cast<VkInstance>( *instance ),
10391  reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
10392  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10393  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10395  {
10396  throwResultException( result, "vkCreateMacOSSurfaceMVK" );
10397  }
10398  }
10399 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
10400 
10401 # if defined( VK_USE_PLATFORM_METAL_EXT )
10402  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10403  VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo,
10405  : m_instance( *instance )
10406  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10407  , m_dispatcher( instance.getDispatcher() )
10408  {
10410  instance.getDispatcher()->vkCreateMetalSurfaceEXT( static_cast<VkInstance>( *instance ),
10411  reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
10412  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10413  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10415  {
10416  throwResultException( result, "vkCreateMetalSurfaceEXT" );
10417  }
10418  }
10419 # endif /*VK_USE_PLATFORM_METAL_EXT*/
10420 
10421 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
10422  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10423  VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo,
10425  : m_instance( *instance )
10426  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10427  , m_dispatcher( instance.getDispatcher() )
10428  {
10430  instance.getDispatcher()->vkCreateScreenSurfaceQNX( static_cast<VkInstance>( *instance ),
10431  reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ),
10432  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10433  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10435  {
10436  throwResultException( result, "vkCreateScreenSurfaceQNX" );
10437  }
10438  }
10439 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
10440 
10441 # if defined( VK_USE_PLATFORM_GGP )
10442  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10443  VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo,
10445  : m_instance( *instance )
10446  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10447  , m_dispatcher( instance.getDispatcher() )
10448  {
10450  instance.getDispatcher()->vkCreateStreamDescriptorSurfaceGGP( static_cast<VkInstance>( *instance ),
10451  reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
10452  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10453  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10455  {
10456  throwResultException( result, "vkCreateStreamDescriptorSurfaceGGP" );
10457  }
10458  }
10459 # endif /*VK_USE_PLATFORM_GGP*/
10460 
10461 # if defined( VK_USE_PLATFORM_VI_NN )
10462  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10463  VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo,
10465  : m_instance( *instance )
10466  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10467  , m_dispatcher( instance.getDispatcher() )
10468  {
10470  instance.getDispatcher()->vkCreateViSurfaceNN( static_cast<VkInstance>( *instance ),
10471  reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
10472  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10473  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10475  {
10476  throwResultException( result, "vkCreateViSurfaceNN" );
10477  }
10478  }
10479 # endif /*VK_USE_PLATFORM_VI_NN*/
10480 
10481 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
10482  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10483  VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo,
10485  : m_instance( *instance )
10486  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10487  , m_dispatcher( instance.getDispatcher() )
10488  {
10490  instance.getDispatcher()->vkCreateWaylandSurfaceKHR( static_cast<VkInstance>( *instance ),
10491  reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
10492  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10493  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10495  {
10496  throwResultException( result, "vkCreateWaylandSurfaceKHR" );
10497  }
10498  }
10499 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
10500 
10501 # if defined( VK_USE_PLATFORM_WIN32_KHR )
10502  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10503  VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo,
10505  : m_instance( *instance )
10506  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10507  , m_dispatcher( instance.getDispatcher() )
10508  {
10510  instance.getDispatcher()->vkCreateWin32SurfaceKHR( static_cast<VkInstance>( *instance ),
10511  reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
10512  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10513  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10515  {
10516  throwResultException( result, "vkCreateWin32SurfaceKHR" );
10517  }
10518  }
10519 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
10520 
10521 # if defined( VK_USE_PLATFORM_XCB_KHR )
10522  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10523  VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo,
10525  : m_instance( *instance )
10526  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10527  , m_dispatcher( instance.getDispatcher() )
10528  {
10530  instance.getDispatcher()->vkCreateXcbSurfaceKHR( static_cast<VkInstance>( *instance ),
10531  reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
10532  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10533  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10535  {
10536  throwResultException( result, "vkCreateXcbSurfaceKHR" );
10537  }
10538  }
10539 # endif /*VK_USE_PLATFORM_XCB_KHR*/
10540 
10541 # if defined( VK_USE_PLATFORM_XLIB_KHR )
10542  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
10543  VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo,
10545  : m_instance( *instance )
10546  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10547  , m_dispatcher( instance.getDispatcher() )
10548  {
10550  instance.getDispatcher()->vkCreateXlibSurfaceKHR( static_cast<VkInstance>( *instance ),
10551  reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
10552  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10553  reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10555  {
10556  throwResultException( result, "vkCreateXlibSurfaceKHR" );
10557  }
10558  }
10559 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
10560 
10562  VkSurfaceKHR surface,
10564  : m_instance( *instance )
10565  , m_surface( surface )
10566  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10567  , m_dispatcher( instance.getDispatcher() )
10568  {
10569  }
10570 
10571  SurfaceKHR( std::nullptr_t ) {}
10572 
10574  {
10575  clear();
10576  }
10577 
10578  SurfaceKHR() = delete;
10579  SurfaceKHR( SurfaceKHR const & ) = delete;
10581  : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
10582  , m_surface( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} ) )
10583  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10585  {
10586  }
10587  SurfaceKHR & operator=( SurfaceKHR const & ) = delete;
10589  {
10590  if ( this != &rhs )
10591  {
10592  clear();
10593  m_instance = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} );
10594  m_surface = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} );
10595  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
10596  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
10597  }
10598  return *this;
10599  }
10600 
10602  {
10603  return m_surface;
10604  }
10605 
10607  {
10608  if ( m_surface )
10609  {
10610  getDispatcher()->vkDestroySurfaceKHR(
10611  static_cast<VkInstance>( m_instance ), static_cast<VkSurfaceKHR>( m_surface ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10612  }
10613  m_instance = nullptr;
10614  m_surface = nullptr;
10615  m_allocator = nullptr;
10616  m_dispatcher = nullptr;
10617  }
10618 
10620  {
10621  m_instance = nullptr;
10622  m_allocator = nullptr;
10623  m_dispatcher = nullptr;
10624  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_surface, nullptr );
10625  }
10626 
10628  {
10629  return m_instance;
10630  }
10631 
10633  {
10635  return m_dispatcher;
10636  }
10637 
10639  {
10640  std::swap( m_instance, rhs.m_instance );
10641  std::swap( m_surface, rhs.m_surface );
10642  std::swap( m_allocator, rhs.m_allocator );
10643  std::swap( m_dispatcher, rhs.m_dispatcher );
10644  }
10645 
10646  private:
10647  VULKAN_HPP_NAMESPACE::Instance m_instance = {};
10648  VULKAN_HPP_NAMESPACE::SurfaceKHR m_surface = {};
10649  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10651  };
10652 
10654  {
10655  public:
10656  using CType = VkSwapchainKHR;
10657 
10661 
10662  public:
10666  : m_device( *device )
10667  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10668  , m_dispatcher( device.getDispatcher() )
10669  {
10671  device.getDispatcher()->vkCreateSwapchainKHR( static_cast<VkDevice>( *device ),
10672  reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
10673  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10674  reinterpret_cast<VkSwapchainKHR *>( &m_swapchain ) ) );
10676  {
10677  throwResultException( result, "vkCreateSwapchainKHR" );
10678  }
10679  }
10680 
10682  VkSwapchainKHR swapchain,
10684  : m_device( *device )
10685  , m_swapchain( swapchain )
10686  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10687  , m_dispatcher( device.getDispatcher() )
10688  {
10689  }
10690 
10691  SwapchainKHR( std::nullptr_t ) {}
10692 
10694  {
10695  clear();
10696  }
10697 
10698  SwapchainKHR() = delete;
10699  SwapchainKHR( SwapchainKHR const & ) = delete;
10701  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10702  , m_swapchain( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} ) )
10703  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10705  {
10706  }
10707  SwapchainKHR & operator=( SwapchainKHR const & ) = delete;
10709  {
10710  if ( this != &rhs )
10711  {
10712  clear();
10713  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
10714  m_swapchain = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} );
10715  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
10716  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
10717  }
10718  return *this;
10719  }
10720 
10722  {
10723  return m_swapchain;
10724  }
10725 
10727  {
10728  if ( m_swapchain )
10729  {
10730  getDispatcher()->vkDestroySwapchainKHR(
10731  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10732  }
10733  m_device = nullptr;
10734  m_swapchain = nullptr;
10735  m_allocator = nullptr;
10736  m_dispatcher = nullptr;
10737  }
10738 
10740  {
10741  m_device = nullptr;
10742  m_allocator = nullptr;
10743  m_dispatcher = nullptr;
10744  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_swapchain, nullptr );
10745  }
10746 
10748  {
10749  return m_device;
10750  }
10751 
10753  {
10755  return m_dispatcher;
10756  }
10757 
10759  {
10760  std::swap( m_device, rhs.m_device );
10761  std::swap( m_swapchain, rhs.m_swapchain );
10762  std::swap( m_allocator, rhs.m_allocator );
10763  std::swap( m_dispatcher, rhs.m_dispatcher );
10764  }
10765 
10766  //=== VK_KHR_swapchain ===
10767 
10768  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Image> getImages() const;
10769 
10770  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
10771  acquireNextImage( uint64_t timeout,
10773  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
10774 
10775  //=== VK_EXT_display_control ===
10776 
10777  VULKAN_HPP_NODISCARD uint64_t getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const;
10778 
10779  //=== VK_GOOGLE_display_timing ===
10780 
10781  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE getRefreshCycleDurationGOOGLE() const;
10782 
10783  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> getPastPresentationTimingGOOGLE() const;
10784 
10785  //=== VK_KHR_shared_presentable_image ===
10786 
10788 
10789  //=== VK_AMD_display_native_hdr ===
10790 
10791  void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT;
10792 
10793  //=== VK_KHR_present_wait ===
10794 
10795  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresent( uint64_t presentId, uint64_t timeout ) const;
10796 
10797 # if defined( VK_USE_PLATFORM_WIN32_KHR )
10798  //=== VK_EXT_full_screen_exclusive ===
10799 
10800  void acquireFullScreenExclusiveModeEXT() const;
10801 
10802  void releaseFullScreenExclusiveModeEXT() const;
10803 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
10804 
10805  private:
10806  VULKAN_HPP_NAMESPACE::Device m_device = {};
10807  VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {};
10808  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10810  };
10811 
10812  class SwapchainKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>
10813  {
10814  public:
10818  {
10820  std::vector<VkSwapchainKHR> swapchains( createInfos.size() );
10822  static_cast<VkDevice>( *device ),
10823  createInfos.size(),
10824  reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
10825  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
10826  swapchains.data() ) );
10828  {
10829  this->reserve( createInfos.size() );
10830  for ( auto const & swapchainKHR : swapchains )
10831  {
10832  this->emplace_back( device, swapchainKHR, allocator );
10833  }
10834  }
10835  else
10836  {
10837  throwResultException( result, "vkCreateSharedSwapchainsKHR" );
10838  }
10839  }
10840 
10841  SwapchainKHRs( std::nullptr_t ) {}
10842 
10843  SwapchainKHRs() = delete;
10844  SwapchainKHRs( SwapchainKHRs const & ) = delete;
10845  SwapchainKHRs( SwapchainKHRs && rhs ) = default;
10846  SwapchainKHRs & operator=( SwapchainKHRs const & ) = delete;
10847  SwapchainKHRs & operator=( SwapchainKHRs && rhs ) = default;
10848  };
10849 
10851  {
10852  public:
10853  using CType = VkValidationCacheEXT;
10854 
10858 
10859  public:
10863  : m_device( *device )
10864  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10865  , m_dispatcher( device.getDispatcher() )
10866  {
10868  device.getDispatcher()->vkCreateValidationCacheEXT( static_cast<VkDevice>( *device ),
10869  reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
10870  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10871  reinterpret_cast<VkValidationCacheEXT *>( &m_validationCache ) ) );
10873  {
10874  throwResultException( result, "vkCreateValidationCacheEXT" );
10875  }
10876  }
10877 
10879  VkValidationCacheEXT validationCache,
10881  : m_device( *device )
10882  , m_validationCache( validationCache )
10883  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10884  , m_dispatcher( device.getDispatcher() )
10885  {
10886  }
10887 
10888  ValidationCacheEXT( std::nullptr_t ) {}
10889 
10891  {
10892  clear();
10893  }
10894 
10895  ValidationCacheEXT() = delete;
10896  ValidationCacheEXT( ValidationCacheEXT const & ) = delete;
10898  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10899  , m_validationCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCache, {} ) )
10900  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10902  {
10903  }
10904  ValidationCacheEXT & operator=( ValidationCacheEXT const & ) = delete;
10906  {
10907  if ( this != &rhs )
10908  {
10909  clear();
10910  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
10911  m_validationCache = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCache, {} );
10912  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
10913  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
10914  }
10915  return *this;
10916  }
10917 
10919  {
10920  return m_validationCache;
10921  }
10922 
10924  {
10925  if ( m_validationCache )
10926  {
10927  getDispatcher()->vkDestroyValidationCacheEXT( static_cast<VkDevice>( m_device ),
10928  static_cast<VkValidationCacheEXT>( m_validationCache ),
10929  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10930  }
10931  m_device = nullptr;
10932  m_validationCache = nullptr;
10933  m_allocator = nullptr;
10934  m_dispatcher = nullptr;
10935  }
10936 
10938  {
10939  m_device = nullptr;
10940  m_allocator = nullptr;
10941  m_dispatcher = nullptr;
10942  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_validationCache, nullptr );
10943  }
10944 
10946  {
10947  return m_device;
10948  }
10949 
10951  {
10953  return m_dispatcher;
10954  }
10955 
10957  {
10958  std::swap( m_device, rhs.m_device );
10959  std::swap( m_validationCache, rhs.m_validationCache );
10960  std::swap( m_allocator, rhs.m_allocator );
10961  std::swap( m_dispatcher, rhs.m_dispatcher );
10962  }
10963 
10964  //=== VK_EXT_validation_cache ===
10965 
10967 
10968  VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
10969 
10970  private:
10971  VULKAN_HPP_NAMESPACE::Device m_device = {};
10972  VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCache = {};
10973  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10975  };
10976 
10977 # if defined( VK_ENABLE_BETA_EXTENSIONS )
10978  class VideoSessionKHR
10979  {
10980  public:
10981  using CType = VkVideoSessionKHR;
10982 
10983  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
10986 
10987  public:
10988  VideoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10989  VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,
10991  : m_device( *device )
10992  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10993  , m_dispatcher( device.getDispatcher() )
10994  {
10996  device.getDispatcher()->vkCreateVideoSessionKHR( static_cast<VkDevice>( *device ),
10997  reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ),
10998  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10999  reinterpret_cast<VkVideoSessionKHR *>( &m_videoSession ) ) );
11001  {
11002  throwResultException( result, "vkCreateVideoSessionKHR" );
11003  }
11004  }
11005 
11006  VideoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11007  VkVideoSessionKHR videoSession,
11009  : m_device( *device )
11010  , m_videoSession( videoSession )
11011  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
11012  , m_dispatcher( device.getDispatcher() )
11013  {
11014  }
11015 
11016  VideoSessionKHR( std::nullptr_t ) {}
11017 
11018  ~VideoSessionKHR()
11019  {
11020  clear();
11021  }
11022 
11023  VideoSessionKHR() = delete;
11024  VideoSessionKHR( VideoSessionKHR const & ) = delete;
11025  VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT
11026  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
11027  , m_videoSession( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSession, {} ) )
11028  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
11029  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
11030  {
11031  }
11032  VideoSessionKHR & operator=( VideoSessionKHR const & ) = delete;
11033  VideoSessionKHR & operator =( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT
11034  {
11035  if ( this != &rhs )
11036  {
11037  clear();
11038  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
11039  m_videoSession = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSession, {} );
11040  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
11041  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
11042  }
11043  return *this;
11044  }
11045 
11046  VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const VULKAN_HPP_NOEXCEPT
11047  {
11048  return m_videoSession;
11049  }
11050 
11051  void clear() VULKAN_HPP_NOEXCEPT
11052  {
11053  if ( m_videoSession )
11054  {
11055  getDispatcher()->vkDestroyVideoSessionKHR( static_cast<VkDevice>( m_device ),
11056  static_cast<VkVideoSessionKHR>( m_videoSession ),
11057  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
11058  }
11059  m_device = nullptr;
11060  m_videoSession = nullptr;
11061  m_allocator = nullptr;
11062  m_dispatcher = nullptr;
11063  }
11064 
11065  VULKAN_HPP_NAMESPACE::VideoSessionKHR release()
11066  {
11067  m_device = nullptr;
11068  m_allocator = nullptr;
11069  m_dispatcher = nullptr;
11070  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_videoSession, nullptr );
11071  }
11072 
11073  VULKAN_HPP_NAMESPACE::Device getDevice() const
11074  {
11075  return m_device;
11076  }
11077 
11079  {
11081  return m_dispatcher;
11082  }
11083 
11084  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR & rhs ) VULKAN_HPP_NOEXCEPT
11085  {
11086  std::swap( m_device, rhs.m_device );
11087  std::swap( m_videoSession, rhs.m_videoSession );
11088  std::swap( m_allocator, rhs.m_allocator );
11089  std::swap( m_dispatcher, rhs.m_dispatcher );
11090  }
11091 
11092  //=== VK_KHR_video_queue ===
11093 
11094  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> getMemoryRequirements() const;
11095 
11096  void bindMemory( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos ) const;
11097 
11098  private:
11099  VULKAN_HPP_NAMESPACE::Device m_device = {};
11100  VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSession = {};
11101  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
11103  };
11104 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
11105 
11106 # if defined( VK_ENABLE_BETA_EXTENSIONS )
11107  class VideoSessionParametersKHR
11108  {
11109  public:
11110  using CType = VkVideoSessionParametersKHR;
11111 
11112  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
11115 
11116  public:
11117  VideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11118  VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo,
11120  : m_device( *device )
11121  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
11122  , m_dispatcher( device.getDispatcher() )
11123  {
11125  device.getDispatcher()->vkCreateVideoSessionParametersKHR( static_cast<VkDevice>( *device ),
11126  reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ),
11127  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
11128  reinterpret_cast<VkVideoSessionParametersKHR *>( &m_videoSessionParameters ) ) );
11130  {
11131  throwResultException( result, "vkCreateVideoSessionParametersKHR" );
11132  }
11133  }
11134 
11135  VideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11136  VkVideoSessionParametersKHR videoSessionParameters,
11138  : m_device( *device )
11139  , m_videoSessionParameters( videoSessionParameters )
11140  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
11141  , m_dispatcher( device.getDispatcher() )
11142  {
11143  }
11144 
11145  VideoSessionParametersKHR( std::nullptr_t ) {}
11146 
11147  ~VideoSessionParametersKHR()
11148  {
11149  clear();
11150  }
11151 
11152  VideoSessionParametersKHR() = delete;
11153  VideoSessionParametersKHR( VideoSessionParametersKHR const & ) = delete;
11154  VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
11155  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
11156  , m_videoSessionParameters( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} ) )
11157  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
11158  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
11159  {
11160  }
11161  VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & ) = delete;
11162  VideoSessionParametersKHR & operator =( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
11163  {
11164  if ( this != &rhs )
11165  {
11166  clear();
11167  m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} );
11168  m_videoSessionParameters = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} );
11169  m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} );
11170  m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr );
11171  }
11172  return *this;
11173  }
11174 
11175  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const VULKAN_HPP_NOEXCEPT
11176  {
11177  return m_videoSessionParameters;
11178  }
11179 
11180  void clear() VULKAN_HPP_NOEXCEPT
11181  {
11182  if ( m_videoSessionParameters )
11183  {
11184  getDispatcher()->vkDestroyVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
11185  static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ),
11186  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
11187  }
11188  m_device = nullptr;
11189  m_videoSessionParameters = nullptr;
11190  m_allocator = nullptr;
11191  m_dispatcher = nullptr;
11192  }
11193 
11194  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR release()
11195  {
11196  m_device = nullptr;
11197  m_allocator = nullptr;
11198  m_dispatcher = nullptr;
11199  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_videoSessionParameters, nullptr );
11200  }
11201 
11202  VULKAN_HPP_NAMESPACE::Device getDevice() const
11203  {
11204  return m_device;
11205  }
11206 
11208  {
11210  return m_dispatcher;
11211  }
11212 
11213  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR & rhs ) VULKAN_HPP_NOEXCEPT
11214  {
11215  std::swap( m_device, rhs.m_device );
11216  std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters );
11217  std::swap( m_allocator, rhs.m_allocator );
11218  std::swap( m_dispatcher, rhs.m_dispatcher );
11219  }
11220 
11221  //=== VK_KHR_video_queue ===
11222 
11223  void update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const;
11224 
11225  private:
11226  VULKAN_HPP_NAMESPACE::Device m_device = {};
11227  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParameters = {};
11228  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
11230  };
11231 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
11232 
11233  //===========================
11234  //=== COMMAND Definitions ===
11235  //===========================
11236 
11237  //=== VK_VERSION_1_0 ===
11238 
11239  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Instance
11242  {
11243  return VULKAN_HPP_RAII_NAMESPACE::Instance( *this, createInfo, allocator );
11244  }
11245 
11246  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> Instance::enumeratePhysicalDevices() const
11247  {
11249  }
11250 
11251  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT
11252  {
11254  getDispatcher()->vkGetPhysicalDeviceFeatures( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11255  reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) );
11256 
11257  return features;
11258  }
11259 
11261  PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
11262  {
11263  VULKAN_HPP_NAMESPACE::FormatProperties formatProperties;
11264  getDispatcher()->vkGetPhysicalDeviceFormatProperties(
11265  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) );
11266 
11267  return formatProperties;
11268  }
11269 
11271  PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
11276  {
11277  VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties;
11278  VkResult result = getDispatcher()->vkGetPhysicalDeviceImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11279  static_cast<VkFormat>( format ),
11280  static_cast<VkImageType>( type ),
11281  static_cast<VkImageTiling>( tiling ),
11282  static_cast<VkImageUsageFlags>( usage ),
11283  static_cast<VkImageCreateFlags>( flags ),
11284  reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) );
11285  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" );
11286 
11287  return imageFormatProperties;
11288  }
11289 
11290  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties PhysicalDevice::getProperties() const VULKAN_HPP_NOEXCEPT
11291  {
11293  getDispatcher()->vkGetPhysicalDeviceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11294  reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) );
11295 
11296  return properties;
11297  }
11298 
11299  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> PhysicalDevice::getQueueFamilyProperties() const
11300  {
11301  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> queueFamilyProperties;
11302  uint32_t queueFamilyPropertyCount;
11303  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
11304  queueFamilyProperties.resize( queueFamilyPropertyCount );
11305  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11306  &queueFamilyPropertyCount,
11307  reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
11308 
11309  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
11310  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
11311  {
11312  queueFamilyProperties.resize( queueFamilyPropertyCount );
11313  }
11314  return queueFamilyProperties;
11315  }
11316 
11317  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties() const VULKAN_HPP_NOEXCEPT
11318  {
11320  getDispatcher()->vkGetPhysicalDeviceMemoryProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11321  reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) );
11322 
11323  return memoryProperties;
11324  }
11325 
11326  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT
11327  {
11328  PFN_vkVoidFunction result = getDispatcher()->vkGetInstanceProcAddr( static_cast<VkInstance>( m_instance ), name.c_str() );
11329 
11330  return result;
11331  }
11332 
11333  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT
11334  {
11335  PFN_vkVoidFunction result = getDispatcher()->vkGetDeviceProcAddr( static_cast<VkDevice>( m_device ), name.c_str() );
11336 
11337  return result;
11338  }
11339 
11341  PhysicalDevice::createDevice( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo,
11343  {
11344  return VULKAN_HPP_RAII_NAMESPACE::Device( *this, createInfo, allocator );
11345  }
11346 
11347  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties>
11349  {
11350  std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties;
11351  uint32_t propertyCount;
11352  VkResult result;
11353  do
11354  {
11355  result = getDispatcher()->vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr );
11356  if ( ( result == VK_SUCCESS ) && propertyCount )
11357  {
11358  properties.resize( propertyCount );
11359  result = getDispatcher()->vkEnumerateInstanceExtensionProperties(
11360  layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) );
11361  }
11362  } while ( result == VK_INCOMPLETE );
11363  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceExtensionProperties" );
11364  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
11365  if ( propertyCount < properties.size() )
11366  {
11367  properties.resize( propertyCount );
11368  }
11369  return properties;
11370  }
11371 
11372  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties>
11373  PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName ) const
11374  {
11375  std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties;
11376  uint32_t propertyCount;
11377  VkResult result;
11378  do
11379  {
11380  result = getDispatcher()->vkEnumerateDeviceExtensionProperties(
11381  static_cast<VkPhysicalDevice>( m_physicalDevice ), layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr );
11382  if ( ( result == VK_SUCCESS ) && propertyCount )
11383  {
11384  properties.resize( propertyCount );
11385  result = getDispatcher()->vkEnumerateDeviceExtensionProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11386  layerName ? layerName->c_str() : nullptr,
11387  &propertyCount,
11388  reinterpret_cast<VkExtensionProperties *>( properties.data() ) );
11389  }
11390  } while ( result == VK_INCOMPLETE );
11391  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" );
11392  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
11393  if ( propertyCount < properties.size() )
11394  {
11395  properties.resize( propertyCount );
11396  }
11397  return properties;
11398  }
11399 
11400  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> Context::enumerateInstanceLayerProperties() const
11401  {
11402  std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties;
11403  uint32_t propertyCount;
11404  VkResult result;
11405  do
11406  {
11407  result = getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, nullptr );
11408  if ( ( result == VK_SUCCESS ) && propertyCount )
11409  {
11410  properties.resize( propertyCount );
11411  result = getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) );
11412  }
11413  } while ( result == VK_INCOMPLETE );
11414  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceLayerProperties" );
11415  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
11416  if ( propertyCount < properties.size() )
11417  {
11418  properties.resize( propertyCount );
11419  }
11420  return properties;
11421  }
11422 
11423  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> PhysicalDevice::enumerateDeviceLayerProperties() const
11424  {
11425  std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties;
11426  uint32_t propertyCount;
11427  VkResult result;
11428  do
11429  {
11430  result = getDispatcher()->vkEnumerateDeviceLayerProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr );
11431  if ( ( result == VK_SUCCESS ) && propertyCount )
11432  {
11433  properties.resize( propertyCount );
11434  result = getDispatcher()->vkEnumerateDeviceLayerProperties(
11435  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) );
11436  }
11437  } while ( result == VK_INCOMPLETE );
11438  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" );
11439  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
11440  if ( propertyCount < properties.size() )
11441  {
11442  properties.resize( propertyCount );
11443  }
11444  return properties;
11445  }
11446 
11447  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const
11448  {
11449  return VULKAN_HPP_RAII_NAMESPACE::Queue( *this, queueFamilyIndex, queueIndex );
11450  }
11451 
11453  VULKAN_HPP_NAMESPACE::Fence fence ) const
11454  {
11455  VkResult result = getDispatcher()->vkQueueSubmit(
11456  static_cast<VkQueue>( m_queue ), submits.size(), reinterpret_cast<const VkSubmitInfo *>( submits.data() ), static_cast<VkFence>( fence ) );
11457  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" );
11458  }
11459 
11460  VULKAN_HPP_INLINE void Queue::waitIdle() const
11461  {
11462  VkResult result = getDispatcher()->vkQueueWaitIdle( static_cast<VkQueue>( m_queue ) );
11463  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" );
11464  }
11465 
11466  VULKAN_HPP_INLINE void Device::waitIdle() const
11467  {
11468  VkResult result = getDispatcher()->vkDeviceWaitIdle( static_cast<VkDevice>( m_device ) );
11469  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" );
11470  }
11471 
11473  Device::allocateMemory( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo,
11475  {
11476  return VULKAN_HPP_RAII_NAMESPACE::DeviceMemory( *this, allocateInfo, allocator );
11477  }
11478 
11482  {
11483  void * pData;
11484  VkResult result = getDispatcher()->vkMapMemory( static_cast<VkDevice>( m_device ),
11485  static_cast<VkDeviceMemory>( m_memory ),
11486  static_cast<VkDeviceSize>( offset ),
11487  static_cast<VkDeviceSize>( size ),
11488  static_cast<VkMemoryMapFlags>( flags ),
11489  &pData );
11490  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory" );
11491 
11492  return pData;
11493  }
11494 
11495  VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT
11496  {
11497  getDispatcher()->vkUnmapMemory( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ) );
11498  }
11499 
11500  VULKAN_HPP_INLINE void
11501  Device::flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const
11502  {
11503  VkResult result = getDispatcher()->vkFlushMappedMemoryRanges(
11504  static_cast<VkDevice>( m_device ), memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) );
11505  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" );
11506  }
11507 
11508  VULKAN_HPP_INLINE void
11509  Device::invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const
11510  {
11511  VkResult result = getDispatcher()->vkInvalidateMappedMemoryRanges(
11512  static_cast<VkDevice>( m_device ), memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) );
11513  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" );
11514  }
11515 
11516  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT
11517  {
11518  VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes;
11519  getDispatcher()->vkGetDeviceMemoryCommitment(
11520  static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
11521 
11522  return committedMemoryInBytes;
11523  }
11524 
11526  {
11527  VkResult result = getDispatcher()->vkBindBufferMemory( static_cast<VkDevice>( m_device ),
11528  static_cast<VkBuffer>( m_buffer ),
11529  static_cast<VkDeviceMemory>( memory ),
11530  static_cast<VkDeviceSize>( memoryOffset ) );
11531  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Buffer::bindMemory" );
11532  }
11533 
11535  {
11536  VkResult result = getDispatcher()->vkBindImageMemory(
11537  static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) );
11538  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Image::bindMemory" );
11539  }
11540 
11541  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
11542  {
11543  VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
11544  getDispatcher()->vkGetBufferMemoryRequirements(
11545  static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( m_buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
11546 
11547  return memoryRequirements;
11548  }
11549 
11550  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
11551  {
11552  VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
11553  getDispatcher()->vkGetImageMemoryRequirements(
11554  static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
11555 
11556  return memoryRequirements;
11557  }
11558 
11559  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> Image::getSparseMemoryRequirements() const
11560  {
11561  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements;
11562  uint32_t sparseMemoryRequirementCount;
11563  getDispatcher()->vkGetImageSparseMemoryRequirements(
11564  static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr );
11565  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
11566  getDispatcher()->vkGetImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ),
11567  static_cast<VkImage>( m_image ),
11568  &sparseMemoryRequirementCount,
11569  reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
11570 
11571  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
11572  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
11573  {
11574  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
11575  }
11576  return sparseMemoryRequirements;
11577  }
11578 
11579  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
11580  PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
11584  VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const
11585  {
11586  std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> properties;
11587  uint32_t propertyCount;
11588  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11589  static_cast<VkFormat>( format ),
11590  static_cast<VkImageType>( type ),
11591  static_cast<VkSampleCountFlagBits>( samples ),
11592  static_cast<VkImageUsageFlags>( usage ),
11593  static_cast<VkImageTiling>( tiling ),
11594  &propertyCount,
11595  nullptr );
11596  properties.resize( propertyCount );
11597  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11598  static_cast<VkFormat>( format ),
11599  static_cast<VkImageType>( type ),
11600  static_cast<VkSampleCountFlagBits>( samples ),
11601  static_cast<VkImageUsageFlags>( usage ),
11602  static_cast<VkImageTiling>( tiling ),
11603  &propertyCount,
11604  reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
11605 
11606  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
11607  if ( propertyCount < properties.size() )
11608  {
11609  properties.resize( propertyCount );
11610  }
11611  return properties;
11612  }
11613 
11615  VULKAN_HPP_NAMESPACE::Fence fence ) const
11616  {
11617  VkResult result = getDispatcher()->vkQueueBindSparse(
11618  static_cast<VkQueue>( m_queue ), bindInfo.size(), reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ), static_cast<VkFence>( fence ) );
11619  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" );
11620  }
11621 
11623  Device::createFence( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo,
11625  {
11626  return VULKAN_HPP_RAII_NAMESPACE::Fence( *this, createInfo, allocator );
11627  }
11628 
11630  {
11631  VkResult result = getDispatcher()->vkResetFences( static_cast<VkDevice>( m_device ), fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) );
11632  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" );
11633  }
11634 
11636  {
11637  VkResult result = getDispatcher()->vkGetFenceStatus( static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ) );
11638  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
11639  VULKAN_HPP_NAMESPACE_STRING "::Fence::getStatus",
11641 
11642  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
11643  }
11644 
11647  {
11648  VkResult result = getDispatcher()->vkWaitForFences(
11649  static_cast<VkDevice>( m_device ), fences.size(), reinterpret_cast<const VkFence *>( fences.data() ), static_cast<VkBool32>( waitAll ), timeout );
11650  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
11651  VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences",
11653 
11654  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
11655  }
11656 
11658  Device::createSemaphore( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo,
11660  {
11661  return VULKAN_HPP_RAII_NAMESPACE::Semaphore( *this, createInfo, allocator );
11662  }
11663 
11665  Device::createEvent( VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo,
11667  {
11668  return VULKAN_HPP_RAII_NAMESPACE::Event( *this, createInfo, allocator );
11669  }
11670 
11672  {
11673  VkResult result = getDispatcher()->vkGetEventStatus( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) );
11674  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
11675  VULKAN_HPP_NAMESPACE_STRING "::Event::getStatus",
11677 
11678  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
11679  }
11680 
11681  VULKAN_HPP_INLINE void Event::set() const
11682  {
11683  VkResult result = getDispatcher()->vkSetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) );
11684  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Event::set" );
11685  }
11686 
11688  {
11689  VkResult result = getDispatcher()->vkResetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) );
11690  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Event::reset" );
11691  }
11692 
11694  Device::createQueryPool( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo,
11696  {
11697  return VULKAN_HPP_RAII_NAMESPACE::QueryPool( *this, createInfo, allocator );
11698  }
11699 
11700  template <typename DataType>
11701  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>> QueryPool::getResults(
11702  uint32_t firstQuery, uint32_t queryCount, size_t dataSize, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
11703  {
11704  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
11705  std::vector<DataType> data( dataSize / sizeof( DataType ) );
11706  VkResult result = getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
11707  static_cast<VkQueryPool>( m_queryPool ),
11708  firstQuery,
11709  queryCount,
11710  data.size() * sizeof( DataType ),
11711  reinterpret_cast<void *>( data.data() ),
11712  static_cast<VkDeviceSize>( stride ),
11713  static_cast<VkQueryResultFlags>( flags ) );
11714  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
11715  VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResults",
11717 
11718  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data );
11719  }
11720 
11721  template <typename DataType>
11722  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, DataType> QueryPool::getResult(
11723  uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
11724  {
11725  DataType data;
11726  VkResult result = getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
11727  static_cast<VkQueryPool>( m_queryPool ),
11728  firstQuery,
11729  queryCount,
11730  sizeof( DataType ),
11731  reinterpret_cast<void *>( &data ),
11732  static_cast<VkDeviceSize>( stride ),
11733  static_cast<VkQueryResultFlags>( flags ) );
11734  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
11735  VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResult",
11737 
11738  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data );
11739  }
11740 
11742  Device::createBuffer( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo,
11744  {
11745  return VULKAN_HPP_RAII_NAMESPACE::Buffer( *this, createInfo, allocator );
11746  }
11747 
11749  Device::createBufferView( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo,
11751  {
11752  return VULKAN_HPP_RAII_NAMESPACE::BufferView( *this, createInfo, allocator );
11753  }
11754 
11756  Device::createImage( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo,
11758  {
11759  return VULKAN_HPP_RAII_NAMESPACE::Image( *this, createInfo, allocator );
11760  }
11761 
11763  Image::getSubresourceLayout( const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT
11764  {
11766  getDispatcher()->vkGetImageSubresourceLayout( static_cast<VkDevice>( m_device ),
11767  static_cast<VkImage>( m_image ),
11768  reinterpret_cast<const VkImageSubresource *>( &subresource ),
11769  reinterpret_cast<VkSubresourceLayout *>( &layout ) );
11770 
11771  return layout;
11772  }
11773 
11775  Device::createImageView( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo,
11777  {
11778  return VULKAN_HPP_RAII_NAMESPACE::ImageView( *this, createInfo, allocator );
11779  }
11780 
11782  Device::createShaderModule( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo,
11784  {
11785  return VULKAN_HPP_RAII_NAMESPACE::ShaderModule( *this, createInfo, allocator );
11786  }
11787 
11789  Device::createPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo,
11791  {
11792  return VULKAN_HPP_RAII_NAMESPACE::PipelineCache( *this, createInfo, allocator );
11793  }
11794 
11795  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> PipelineCache::getData() const
11796  {
11797  std::vector<uint8_t> data;
11798  size_t dataSize;
11799  VkResult result;
11800  do
11801  {
11802  result =
11803  getDispatcher()->vkGetPipelineCacheData( static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, nullptr );
11804  if ( ( result == VK_SUCCESS ) && dataSize )
11805  {
11806  data.resize( dataSize );
11807  result = getDispatcher()->vkGetPipelineCacheData(
11808  static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, reinterpret_cast<void *>( data.data() ) );
11809  }
11810  } while ( result == VK_INCOMPLETE );
11811  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::getData" );
11812  VULKAN_HPP_ASSERT( dataSize <= data.size() );
11813  if ( dataSize < data.size() )
11814  {
11815  data.resize( dataSize );
11816  }
11817  return data;
11818  }
11819 
11821  {
11822  VkResult result = getDispatcher()->vkMergePipelineCaches( static_cast<VkDevice>( m_device ),
11823  static_cast<VkPipelineCache>( m_pipelineCache ),
11824  srcCaches.size(),
11825  reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) );
11826  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::merge" );
11827  }
11828 
11829  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> Device::createGraphicsPipelines(
11833  {
11834  return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, pipelineCache, createInfos, allocator );
11835  }
11836 
11841  {
11842  return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator );
11843  }
11844 
11845  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> Device::createComputePipelines(
11849  {
11850  return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, pipelineCache, createInfos, allocator );
11851  }
11852 
11857  {
11858  return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator );
11859  }
11860 
11862  Device::createPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo,
11864  {
11865  return VULKAN_HPP_RAII_NAMESPACE::PipelineLayout( *this, createInfo, allocator );
11866  }
11867 
11871  {
11872  return VULKAN_HPP_RAII_NAMESPACE::Sampler( *this, createInfo, allocator );
11873  }
11874 
11876  Device::createDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo,
11878  {
11879  return VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout( *this, createInfo, allocator );
11880  }
11881 
11883  Device::createDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo,
11885  {
11886  return VULKAN_HPP_RAII_NAMESPACE::DescriptorPool( *this, createInfo, allocator );
11887  }
11888 
11890  {
11891  getDispatcher()->vkResetDescriptorPool(
11892  static_cast<VkDevice>( m_device ), static_cast<VkDescriptorPool>( m_descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) );
11893  }
11894 
11895  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>
11896  Device::allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const
11897  {
11898  return VULKAN_HPP_RAII_NAMESPACE::DescriptorSets( *this, allocateInfo );
11899  }
11900 
11901  VULKAN_HPP_INLINE void Device::updateDescriptorSets(
11903  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT
11904  {
11905  getDispatcher()->vkUpdateDescriptorSets( static_cast<VkDevice>( m_device ),
11906  descriptorWrites.size(),
11907  reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ),
11908  descriptorCopies.size(),
11909  reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) );
11910  }
11911 
11913  Device::createFramebuffer( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo,
11915  {
11916  return VULKAN_HPP_RAII_NAMESPACE::Framebuffer( *this, createInfo, allocator );
11917  }
11918 
11920  Device::createRenderPass( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo,
11922  {
11923  return VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, createInfo, allocator );
11924  }
11925 
11926  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT
11927  {
11928  VULKAN_HPP_NAMESPACE::Extent2D granularity;
11929  getDispatcher()->vkGetRenderAreaGranularity(
11930  static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) );
11931 
11932  return granularity;
11933  }
11934 
11936  Device::createCommandPool( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo,
11938  {
11939  return VULKAN_HPP_RAII_NAMESPACE::CommandPool( *this, createInfo, allocator );
11940  }
11941 
11943  {
11944  VkResult result = getDispatcher()->vkResetCommandPool(
11945  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) );
11946  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandPool::reset" );
11947  }
11948 
11949  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>
11950  Device::allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const
11951  {
11952  return VULKAN_HPP_RAII_NAMESPACE::CommandBuffers( *this, allocateInfo );
11953  }
11954 
11956  {
11957  VkResult result = getDispatcher()->vkBeginCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
11958  reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) );
11959  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" );
11960  }
11961 
11963  {
11964  VkResult result = getDispatcher()->vkEndCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ) );
11965  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" );
11966  }
11967 
11969  {
11970  VkResult result =
11971  getDispatcher()->vkResetCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCommandBufferResetFlags>( flags ) );
11972  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" );
11973  }
11974 
11975  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
11976  VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT
11977  {
11978  getDispatcher()->vkCmdBindPipeline(
11979  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
11980  }
11981 
11982  VULKAN_HPP_INLINE void
11983  CommandBuffer::setViewport( uint32_t firstViewport,
11984  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
11985  {
11986  getDispatcher()->vkCmdSetViewport(
11987  static_cast<VkCommandBuffer>( m_commandBuffer ), firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
11988  }
11989 
11990  VULKAN_HPP_INLINE void
11991  CommandBuffer::setScissor( uint32_t firstScissor,
11992  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
11993  {
11994  getDispatcher()->vkCmdSetScissor(
11995  static_cast<VkCommandBuffer>( m_commandBuffer ), firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
11996  }
11997 
11998  VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT
11999  {
12000  getDispatcher()->vkCmdSetLineWidth( static_cast<VkCommandBuffer>( m_commandBuffer ), lineWidth );
12001  }
12002 
12003  VULKAN_HPP_INLINE void
12004  CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
12005  {
12006  getDispatcher()->vkCmdSetDepthBias( static_cast<VkCommandBuffer>( m_commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
12007  }
12008 
12009  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
12010  {
12011  getDispatcher()->vkCmdSetBlendConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), blendConstants );
12012  }
12013 
12014  VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
12015  {
12016  getDispatcher()->vkCmdSetDepthBounds( static_cast<VkCommandBuffer>( m_commandBuffer ), minDepthBounds, maxDepthBounds );
12017  }
12018 
12019  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
12020  uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
12021  {
12022  getDispatcher()->vkCmdSetStencilCompareMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
12023  }
12024 
12025  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
12026  {
12027  getDispatcher()->vkCmdSetStencilWriteMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
12028  }
12029 
12030  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
12031  {
12032  getDispatcher()->vkCmdSetStencilReference( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), reference );
12033  }
12034 
12035  VULKAN_HPP_INLINE void
12036  CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
12038  uint32_t firstSet,
12040  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT
12041  {
12042  getDispatcher()->vkCmdBindDescriptorSets( static_cast<VkCommandBuffer>( m_commandBuffer ),
12043  static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
12044  static_cast<VkPipelineLayout>( layout ),
12045  firstSet,
12046  descriptorSets.size(),
12047  reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ),
12048  dynamicOffsets.size(),
12049  dynamicOffsets.data() );
12050  }
12051 
12052  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer,
12054  VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT
12055  {
12056  getDispatcher()->vkCmdBindIndexBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12057  static_cast<VkBuffer>( buffer ),
12058  static_cast<VkDeviceSize>( offset ),
12059  static_cast<VkIndexType>( indexType ) );
12060  }
12061 
12062  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding,
12065  {
12066  if ( buffers.size() != offsets.size() )
12067  {
12068  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
12069  }
12070 
12071  getDispatcher()->vkCmdBindVertexBuffers( static_cast<VkCommandBuffer>( m_commandBuffer ),
12072  firstBinding,
12073  buffers.size(),
12074  reinterpret_cast<const VkBuffer *>( buffers.data() ),
12075  reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
12076  }
12077 
12078  VULKAN_HPP_INLINE void
12079  CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
12080  {
12081  getDispatcher()->vkCmdDraw( static_cast<VkCommandBuffer>( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance );
12082  }
12083 
12084  VULKAN_HPP_INLINE void CommandBuffer::drawIndexed(
12085  uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
12086  {
12087  getDispatcher()->vkCmdDrawIndexed( static_cast<VkCommandBuffer>( m_commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
12088  }
12089 
12090  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
12092  uint32_t drawCount,
12093  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
12094  {
12095  getDispatcher()->vkCmdDrawIndirect(
12096  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
12097  }
12098 
12099  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
12101  uint32_t drawCount,
12102  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
12103  {
12104  getDispatcher()->vkCmdDrawIndexedIndirect(
12105  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
12106  }
12107 
12108  VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
12109  {
12110  getDispatcher()->vkCmdDispatch( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
12111  }
12112 
12113  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
12114  VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT
12115  {
12116  getDispatcher()->vkCmdDispatchIndirect(
12117  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
12118  }
12119 
12120  VULKAN_HPP_INLINE void
12121  CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
12122  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
12123  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
12124  {
12125  getDispatcher()->vkCmdCopyBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12126  static_cast<VkBuffer>( srcBuffer ),
12127  static_cast<VkBuffer>( dstBuffer ),
12128  regions.size(),
12129  reinterpret_cast<const VkBufferCopy *>( regions.data() ) );
12130  }
12131 
12132  VULKAN_HPP_INLINE void
12133  CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
12134  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
12135  VULKAN_HPP_NAMESPACE::Image dstImage,
12136  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
12137  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
12138  {
12139  getDispatcher()->vkCmdCopyImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
12140  static_cast<VkImage>( srcImage ),
12141  static_cast<VkImageLayout>( srcImageLayout ),
12142  static_cast<VkImage>( dstImage ),
12143  static_cast<VkImageLayout>( dstImageLayout ),
12144  regions.size(),
12145  reinterpret_cast<const VkImageCopy *>( regions.data() ) );
12146  }
12147 
12148  VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
12149  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
12150  VULKAN_HPP_NAMESPACE::Image dstImage,
12151  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
12153  VULKAN_HPP_NAMESPACE::Filter filter ) const VULKAN_HPP_NOEXCEPT
12154  {
12155  getDispatcher()->vkCmdBlitImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
12156  static_cast<VkImage>( srcImage ),
12157  static_cast<VkImageLayout>( srcImageLayout ),
12158  static_cast<VkImage>( dstImage ),
12159  static_cast<VkImageLayout>( dstImageLayout ),
12160  regions.size(),
12161  reinterpret_cast<const VkImageBlit *>( regions.data() ),
12162  static_cast<VkFilter>( filter ) );
12163  }
12164 
12165  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage(
12166  VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
12167  VULKAN_HPP_NAMESPACE::Image dstImage,
12168  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
12169  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
12170  {
12171  getDispatcher()->vkCmdCopyBufferToImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
12172  static_cast<VkBuffer>( srcBuffer ),
12173  static_cast<VkImage>( dstImage ),
12174  static_cast<VkImageLayout>( dstImageLayout ),
12175  regions.size(),
12176  reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
12177  }
12178 
12179  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer(
12180  VULKAN_HPP_NAMESPACE::Image srcImage,
12181  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
12182  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
12183  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
12184  {
12185  getDispatcher()->vkCmdCopyImageToBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12186  static_cast<VkImage>( srcImage ),
12187  static_cast<VkImageLayout>( srcImageLayout ),
12188  static_cast<VkBuffer>( dstBuffer ),
12189  regions.size(),
12190  reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
12191  }
12192 
12193  template <typename DataType>
12194  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
12196  VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data ) const VULKAN_HPP_NOEXCEPT
12197  {
12198  getDispatcher()->vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12199  static_cast<VkBuffer>( dstBuffer ),
12200  static_cast<VkDeviceSize>( dstOffset ),
12201  data.size() * sizeof( DataType ),
12202  reinterpret_cast<const void *>( data.data() ) );
12203  }
12204 
12205  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
12208  uint32_t data ) const VULKAN_HPP_NOEXCEPT
12209  {
12210  getDispatcher()->vkCmdFillBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12211  static_cast<VkBuffer>( dstBuffer ),
12212  static_cast<VkDeviceSize>( dstOffset ),
12213  static_cast<VkDeviceSize>( size ),
12214  data );
12215  }
12216 
12217  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage(
12222  {
12223  getDispatcher()->vkCmdClearColorImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
12224  static_cast<VkImage>( image ),
12225  static_cast<VkImageLayout>( imageLayout ),
12226  reinterpret_cast<const VkClearColorValue *>( &color ),
12227  ranges.size(),
12228  reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
12229  }
12230 
12231  VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage(
12234  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil,
12236  {
12237  getDispatcher()->vkCmdClearDepthStencilImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
12238  static_cast<VkImage>( image ),
12239  static_cast<VkImageLayout>( imageLayout ),
12240  reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ),
12241  ranges.size(),
12242  reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
12243  }
12244 
12245  VULKAN_HPP_INLINE void
12247  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects ) const VULKAN_HPP_NOEXCEPT
12248  {
12249  getDispatcher()->vkCmdClearAttachments( static_cast<VkCommandBuffer>( m_commandBuffer ),
12250  attachments.size(),
12251  reinterpret_cast<const VkClearAttachment *>( attachments.data() ),
12252  rects.size(),
12253  reinterpret_cast<const VkClearRect *>( rects.data() ) );
12254  }
12255 
12256  VULKAN_HPP_INLINE void
12257  CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage,
12258  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
12259  VULKAN_HPP_NAMESPACE::Image dstImage,
12260  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
12261  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT
12262  {
12263  getDispatcher()->vkCmdResolveImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
12264  static_cast<VkImage>( srcImage ),
12265  static_cast<VkImageLayout>( srcImageLayout ),
12266  static_cast<VkImage>( dstImage ),
12267  static_cast<VkImageLayout>( dstImageLayout ),
12268  regions.size(),
12269  reinterpret_cast<const VkImageResolve *>( regions.data() ) );
12270  }
12271 
12272  VULKAN_HPP_INLINE void CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event event,
12273  VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
12274  {
12275  getDispatcher()->vkCmdSetEvent(
12276  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
12277  }
12278 
12279  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event,
12280  VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
12281  {
12282  getDispatcher()->vkCmdResetEvent(
12283  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
12284  }
12285 
12286  VULKAN_HPP_INLINE void CommandBuffer::waitEvents(
12292  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
12293  {
12294  getDispatcher()->vkCmdWaitEvents( static_cast<VkCommandBuffer>( m_commandBuffer ),
12295  events.size(),
12296  reinterpret_cast<const VkEvent *>( events.data() ),
12297  static_cast<VkPipelineStageFlags>( srcStageMask ),
12298  static_cast<VkPipelineStageFlags>( dstStageMask ),
12299  memoryBarriers.size(),
12300  reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
12301  bufferMemoryBarriers.size(),
12302  reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
12303  imageMemoryBarriers.size(),
12304  reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
12305  }
12306 
12307  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier(
12310  VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
12313  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
12314  {
12315  getDispatcher()->vkCmdPipelineBarrier( static_cast<VkCommandBuffer>( m_commandBuffer ),
12316  static_cast<VkPipelineStageFlags>( srcStageMask ),
12317  static_cast<VkPipelineStageFlags>( dstStageMask ),
12318  static_cast<VkDependencyFlags>( dependencyFlags ),
12319  memoryBarriers.size(),
12320  reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
12321  bufferMemoryBarriers.size(),
12322  reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
12323  imageMemoryBarriers.size(),
12324  reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
12325  }
12326 
12327  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
12328  uint32_t query,
12329  VULKAN_HPP_NAMESPACE::QueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
12330  {
12331  getDispatcher()->vkCmdBeginQuery(
12332  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
12333  }
12334 
12335  VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
12336  {
12337  getDispatcher()->vkCmdEndQuery( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query );
12338  }
12339 
12340  VULKAN_HPP_INLINE void
12341  CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
12342  {
12343  getDispatcher()->vkCmdResetQueryPool( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
12344  }
12345 
12346  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
12348  uint32_t query ) const VULKAN_HPP_NOEXCEPT
12349  {
12350  getDispatcher()->vkCmdWriteTimestamp(
12351  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
12352  }
12353 
12354  VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
12355  uint32_t firstQuery,
12356  uint32_t queryCount,
12357  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
12360  VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
12361  {
12362  getDispatcher()->vkCmdCopyQueryPoolResults( static_cast<VkCommandBuffer>( m_commandBuffer ),
12363  static_cast<VkQueryPool>( queryPool ),
12364  firstQuery,
12365  queryCount,
12366  static_cast<VkBuffer>( dstBuffer ),
12367  static_cast<VkDeviceSize>( dstOffset ),
12368  static_cast<VkDeviceSize>( stride ),
12369  static_cast<VkQueryResultFlags>( flags ) );
12370  }
12371 
12372  template <typename ValuesType>
12373  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
12375  uint32_t offset,
12376  VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values ) const VULKAN_HPP_NOEXCEPT
12377  {
12378  getDispatcher()->vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ),
12379  static_cast<VkPipelineLayout>( layout ),
12380  static_cast<VkShaderStageFlags>( stageFlags ),
12381  offset,
12382  values.size() * sizeof( ValuesType ),
12383  reinterpret_cast<const void *>( values.data() ) );
12384  }
12385 
12386  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
12387  VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT
12388  {
12389  getDispatcher()->vkCmdBeginRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ),
12390  reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
12391  static_cast<VkSubpassContents>( contents ) );
12392  }
12393 
12394  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT
12395  {
12396  getDispatcher()->vkCmdNextSubpass( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkSubpassContents>( contents ) );
12397  }
12398 
12399  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const VULKAN_HPP_NOEXCEPT
12400  {
12401  getDispatcher()->vkCmdEndRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ) );
12402  }
12403 
12404  VULKAN_HPP_INLINE void CommandBuffer::executeCommands(
12405  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const VULKAN_HPP_NOEXCEPT
12406  {
12407  getDispatcher()->vkCmdExecuteCommands(
12408  static_cast<VkCommandBuffer>( m_commandBuffer ), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
12409  }
12410 
12411  //=== VK_VERSION_1_1 ===
12412 
12414  {
12415  uint32_t apiVersion;
12416  VkResult result = getDispatcher()->vkEnumerateInstanceVersion( &apiVersion );
12417  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceVersion" );
12418 
12419  return apiVersion;
12420  }
12421 
12422  VULKAN_HPP_INLINE void
12424  {
12425  VkResult result = getDispatcher()->vkBindBufferMemory2(
12426  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) );
12427  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" );
12428  }
12429 
12431  {
12432  VkResult result = getDispatcher()->vkBindImageMemory2(
12433  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) );
12434  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" );
12435  }
12436 
12438  Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT
12439  {
12441  getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures( static_cast<VkDevice>( m_device ),
12442  heapIndex,
12443  localDeviceIndex,
12444  remoteDeviceIndex,
12445  reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
12446 
12447  return peerMemoryFeatures;
12448  }
12449 
12450  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
12451  {
12452  getDispatcher()->vkCmdSetDeviceMask( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
12453  }
12454 
12455  VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX,
12456  uint32_t baseGroupY,
12457  uint32_t baseGroupZ,
12458  uint32_t groupCountX,
12459  uint32_t groupCountY,
12460  uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
12461  {
12462  getDispatcher()->vkCmdDispatchBase(
12463  static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
12464  }
12465 
12466  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> Instance::enumeratePhysicalDeviceGroups() const
12467  {
12468  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
12469  uint32_t physicalDeviceGroupCount;
12470  VkResult result;
12471  do
12472  {
12473  result = getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr );
12474  if ( ( result == VK_SUCCESS ) && physicalDeviceGroupCount )
12475  {
12476  physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
12477  result =
12478  getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast<VkInstance>( m_instance ),
12479  &physicalDeviceGroupCount,
12480  reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) );
12481  }
12482  } while ( result == VK_INCOMPLETE );
12483  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
12484  VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
12485  if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
12486  {
12487  physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
12488  }
12489  return physicalDeviceGroupProperties;
12490  }
12491 
12493  Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
12494  {
12495  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
12496  getDispatcher()->vkGetImageMemoryRequirements2( static_cast<VkDevice>( m_device ),
12497  reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
12498  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
12499 
12500  return memoryRequirements;
12501  }
12502 
12503  template <typename X, typename Y, typename... Z>
12505  Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
12506  {
12507  StructureChain<X, Y, Z...> structureChain;
12508  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
12509  getDispatcher()->vkGetImageMemoryRequirements2( static_cast<VkDevice>( m_device ),
12510  reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
12511  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
12512 
12513  return structureChain;
12514  }
12515 
12517  Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
12518  {
12519  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
12520  getDispatcher()->vkGetBufferMemoryRequirements2( static_cast<VkDevice>( m_device ),
12521  reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
12522  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
12523 
12524  return memoryRequirements;
12525  }
12526 
12527  template <typename X, typename Y, typename... Z>
12529  Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
12530  {
12531  StructureChain<X, Y, Z...> structureChain;
12532  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
12533  getDispatcher()->vkGetBufferMemoryRequirements2( static_cast<VkDevice>( m_device ),
12534  reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
12535  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
12536 
12537  return structureChain;
12538  }
12539 
12540  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
12541  Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const
12542  {
12543  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
12544  uint32_t sparseMemoryRequirementCount;
12545  getDispatcher()->vkGetImageSparseMemoryRequirements2(
12546  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
12547  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
12548  getDispatcher()->vkGetImageSparseMemoryRequirements2( static_cast<VkDevice>( m_device ),
12549  reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
12550  &sparseMemoryRequirementCount,
12551  reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
12552 
12553  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
12554  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
12555  {
12556  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
12557  }
12558  return sparseMemoryRequirements;
12559  }
12560 
12561  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT
12562  {
12564  getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12565  reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
12566 
12567  return features;
12568  }
12569 
12570  template <typename X, typename Y, typename... Z>
12571  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT
12572  {
12573  StructureChain<X, Y, Z...> structureChain;
12574  VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
12575  getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12576  reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
12577 
12578  return structureChain;
12579  }
12580 
12581  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT
12582  {
12584  getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12585  reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
12586 
12587  return properties;
12588  }
12589 
12590  template <typename X, typename Y, typename... Z>
12591  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT
12592  {
12593  StructureChain<X, Y, Z...> structureChain;
12594  VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
12595  getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12596  reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
12597 
12598  return structureChain;
12599  }
12600 
12602  PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
12603  {
12604  VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
12605  getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
12606  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
12607 
12608  return formatProperties;
12609  }
12610 
12611  template <typename X, typename Y, typename... Z>
12613  PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
12614  {
12615  StructureChain<X, Y, Z...> structureChain;
12616  VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
12617  getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
12618  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
12619 
12620  return structureChain;
12621  }
12622 
12624  PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
12625  {
12626  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
12627  VkResult result =
12628  getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12629  reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
12630  reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
12631  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
12632 
12633  return imageFormatProperties;
12634  }
12635 
12636  template <typename X, typename Y, typename... Z>
12638  PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
12639  {
12640  StructureChain<X, Y, Z...> structureChain;
12641  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
12642  VkResult result =
12643  getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12644  reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
12645  reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
12646  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
12647 
12648  return structureChain;
12649  }
12650 
12651  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> PhysicalDevice::getQueueFamilyProperties2() const
12652  {
12653  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
12654  uint32_t queueFamilyPropertyCount;
12655  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
12656  queueFamilyProperties.resize( queueFamilyPropertyCount );
12657  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12658  &queueFamilyPropertyCount,
12659  reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
12660 
12661  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
12662  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
12663  {
12664  queueFamilyProperties.resize( queueFamilyPropertyCount );
12665  }
12666  return queueFamilyProperties;
12667  }
12668 
12669  template <typename StructureChain>
12670  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2() const
12671  {
12672  std::vector<StructureChain> structureChains;
12673  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
12674  uint32_t queueFamilyPropertyCount;
12675  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
12676  structureChains.resize( queueFamilyPropertyCount );
12677  queueFamilyProperties.resize( queueFamilyPropertyCount );
12678  for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
12679  {
12680  queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
12681  }
12682  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12683  &queueFamilyPropertyCount,
12684  reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
12685 
12686  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
12687  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
12688  {
12689  structureChains.resize( queueFamilyPropertyCount );
12690  }
12691  for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
12692  {
12693  structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
12694  }
12695  return structureChains;
12696  }
12697 
12699  PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
12700  {
12702  getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12703  reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
12704 
12705  return memoryProperties;
12706  }
12707 
12708  template <typename X, typename Y, typename... Z>
12709  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
12710  {
12711  StructureChain<X, Y, Z...> structureChain;
12713  structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
12714  getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12715  reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
12716 
12717  return structureChain;
12718  }
12719 
12720  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
12721  PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const
12722  {
12723  std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties;
12724  uint32_t propertyCount;
12725  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12726  reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
12727  &propertyCount,
12728  nullptr );
12729  properties.resize( propertyCount );
12730  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12731  reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
12732  &propertyCount,
12733  reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
12734 
12735  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
12736  if ( propertyCount < properties.size() )
12737  {
12738  properties.resize( propertyCount );
12739  }
12740  return properties;
12741  }
12742 
12744  {
12745  getDispatcher()->vkTrimCommandPool(
12746  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
12747  }
12748 
12750  {
12751  return VULKAN_HPP_RAII_NAMESPACE::Queue( *this, queueInfo );
12752  }
12753 
12755  Device::createSamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,
12757  {
12758  return VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion( *this, createInfo, allocator );
12759  }
12760 
12762  Device::createDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,
12764  {
12765  return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( *this, createInfo, allocator );
12766  }
12767 
12768  template <typename DataType>
12769  VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
12770  DataType const & data ) const VULKAN_HPP_NOEXCEPT
12771  {
12772  getDispatcher()->vkUpdateDescriptorSetWithTemplate( static_cast<VkDevice>( m_device ),
12773  static_cast<VkDescriptorSet>( m_descriptorSet ),
12774  static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
12775  reinterpret_cast<const void *>( &data ) );
12776  }
12777 
12779  PhysicalDevice::getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT
12780  {
12781  VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
12782  getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12783  reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
12784  reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
12785 
12786  return externalBufferProperties;
12787  }
12788 
12790  PhysicalDevice::getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT
12791  {
12792  VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
12793  getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12794  reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
12795  reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
12796 
12797  return externalFenceProperties;
12798  }
12799 
12801  const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
12802  {
12803  VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
12804  getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties(
12805  static_cast<VkPhysicalDevice>( m_physicalDevice ),
12806  reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
12807  reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
12808 
12809  return externalSemaphoreProperties;
12810  }
12811 
12813  Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
12814  {
12816  getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast<VkDevice>( m_device ),
12817  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
12818  reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
12819 
12820  return support;
12821  }
12822 
12823  template <typename X, typename Y, typename... Z>
12825  Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
12826  {
12827  StructureChain<X, Y, Z...> structureChain;
12828  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
12829  getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast<VkDevice>( m_device ),
12830  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
12831  reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
12832 
12833  return structureChain;
12834  }
12835 
12836  //=== VK_VERSION_1_2 ===
12837 
12838  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
12840  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
12841  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
12842  uint32_t maxDrawCount,
12843  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
12844  {
12845  getDispatcher()->vkCmdDrawIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
12846  static_cast<VkBuffer>( buffer ),
12847  static_cast<VkDeviceSize>( offset ),
12848  static_cast<VkBuffer>( countBuffer ),
12849  static_cast<VkDeviceSize>( countBufferOffset ),
12850  maxDrawCount,
12851  stride );
12852  }
12853 
12854  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
12856  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
12857  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
12858  uint32_t maxDrawCount,
12859  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
12860  {
12861  getDispatcher()->vkCmdDrawIndexedIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
12862  static_cast<VkBuffer>( buffer ),
12863  static_cast<VkDeviceSize>( offset ),
12864  static_cast<VkBuffer>( countBuffer ),
12865  static_cast<VkDeviceSize>( countBufferOffset ),
12866  maxDrawCount,
12867  stride );
12868  }
12869 
12871  Device::createRenderPass2( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,
12873  {
12874  return VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, createInfo, allocator );
12875  }
12876 
12877  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
12878  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
12879  {
12880  getDispatcher()->vkCmdBeginRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
12881  reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
12882  reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
12883  }
12884 
12885  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
12886  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
12887  {
12888  getDispatcher()->vkCmdNextSubpass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
12889  reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
12890  reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
12891  }
12892 
12893  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
12894  {
12895  getDispatcher()->vkCmdEndRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
12896  }
12897 
12898  VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
12899  {
12900  getDispatcher()->vkResetQueryPool( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
12901  }
12902 
12903  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValue() const
12904  {
12905  uint64_t value;
12906  VkResult result = getDispatcher()->vkGetSemaphoreCounterValue( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value );
12907  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" );
12908 
12909  return value;
12910  }
12911 
12913  uint64_t timeout ) const
12914  {
12915  VkResult result =
12916  getDispatcher()->vkWaitSemaphores( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout );
12917  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
12918  VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores",
12920 
12921  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
12922  }
12923 
12924  VULKAN_HPP_INLINE void Device::signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const
12925  {
12926  VkResult result = getDispatcher()->vkSignalSemaphore( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) );
12927  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" );
12928  }
12929 
12931  Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
12932  {
12933  VkDeviceAddress result =
12934  getDispatcher()->vkGetBufferDeviceAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
12935 
12936  return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result );
12937  }
12938 
12940  Device::getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
12941  {
12942  uint64_t result =
12943  getDispatcher()->vkGetBufferOpaqueCaptureAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
12944 
12945  return result;
12946  }
12947 
12949  Device::getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
12950  {
12951  uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress( static_cast<VkDevice>( m_device ),
12952  reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
12953 
12954  return result;
12955  }
12956 
12957  //=== VK_VERSION_1_3 ===
12958 
12959  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> PhysicalDevice::getToolProperties() const
12960  {
12961  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties;
12962  uint32_t toolCount;
12963  VkResult result;
12964  do
12965  {
12966  result = getDispatcher()->vkGetPhysicalDeviceToolProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, nullptr );
12967  if ( ( result == VK_SUCCESS ) && toolCount )
12968  {
12969  toolProperties.resize( toolCount );
12970  result = getDispatcher()->vkGetPhysicalDeviceToolProperties(
12971  static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) );
12972  }
12973  } while ( result == VK_INCOMPLETE );
12974  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" );
12975  VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
12976  if ( toolCount < toolProperties.size() )
12977  {
12978  toolProperties.resize( toolCount );
12979  }
12980  return toolProperties;
12981  }
12982 
12984  Device::createPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,
12986  {
12987  return VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot( *this, createInfo, allocator );
12988  }
12989 
12990  VULKAN_HPP_INLINE void Device::setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
12991  uint64_t objectHandle,
12992  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
12993  uint64_t data ) const
12994  {
12995  VkResult result = getDispatcher()->vkSetPrivateData(
12996  static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data );
12997  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData" );
12998  }
12999 
13000  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
13001  uint64_t objectHandle,
13002  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT
13003  {
13004  uint64_t data;
13005  getDispatcher()->vkGetPrivateData(
13006  static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
13007 
13008  return data;
13009  }
13010 
13011  VULKAN_HPP_INLINE void CommandBuffer::setEvent2( VULKAN_HPP_NAMESPACE::Event event,
13012  const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
13013  {
13014  getDispatcher()->vkCmdSetEvent2(
13015  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
13016  }
13017 
13018  VULKAN_HPP_INLINE void CommandBuffer::resetEvent2( VULKAN_HPP_NAMESPACE::Event event,
13019  VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
13020  {
13021  getDispatcher()->vkCmdResetEvent2(
13022  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) );
13023  }
13024 
13025  VULKAN_HPP_INLINE void
13028  {
13029  if ( events.size() != dependencyInfos.size() )
13030  {
13031  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()" );
13032  }
13033 
13034  getDispatcher()->vkCmdWaitEvents2( static_cast<VkCommandBuffer>( m_commandBuffer ),
13035  events.size(),
13036  reinterpret_cast<const VkEvent *>( events.data() ),
13037  reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) );
13038  }
13039 
13040  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
13041  {
13042  getDispatcher()->vkCmdPipelineBarrier2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
13043  }
13044 
13045  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
13047  uint32_t query ) const VULKAN_HPP_NOEXCEPT
13048  {
13049  getDispatcher()->vkCmdWriteTimestamp2(
13050  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query );
13051  }
13052 
13054  VULKAN_HPP_NAMESPACE::Fence fence ) const
13055  {
13056  VkResult result = getDispatcher()->vkQueueSubmit2(
13057  static_cast<VkQueue>( m_queue ), submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) );
13058  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2" );
13059  }
13060 
13061  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT
13062  {
13063  getDispatcher()->vkCmdCopyBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( &copyBufferInfo ) );
13064  }
13065 
13066  VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT
13067  {
13068  getDispatcher()->vkCmdCopyImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( &copyImageInfo ) );
13069  }
13070 
13071  VULKAN_HPP_INLINE void
13072  CommandBuffer::copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
13073  {
13074  getDispatcher()->vkCmdCopyBufferToImage2( static_cast<VkCommandBuffer>( m_commandBuffer ),
13075  reinterpret_cast<const VkCopyBufferToImageInfo2 *>( &copyBufferToImageInfo ) );
13076  }
13077 
13078  VULKAN_HPP_INLINE void
13079  CommandBuffer::copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
13080  {
13081  getDispatcher()->vkCmdCopyImageToBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ),
13082  reinterpret_cast<const VkCopyImageToBufferInfo2 *>( &copyImageToBufferInfo ) );
13083  }
13084 
13085  VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT
13086  {
13087  getDispatcher()->vkCmdBlitImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
13088  }
13089 
13090  VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT
13091  {
13092  getDispatcher()->vkCmdResolveImage2( static_cast<VkCommandBuffer>( m_commandBuffer ),
13093  reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
13094  }
13095 
13096  VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT
13097  {
13098  getDispatcher()->vkCmdBeginRendering( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
13099  }
13100 
13101  VULKAN_HPP_INLINE void CommandBuffer::endRendering() const VULKAN_HPP_NOEXCEPT
13102  {
13103  getDispatcher()->vkCmdEndRendering( static_cast<VkCommandBuffer>( m_commandBuffer ) );
13104  }
13105 
13106  VULKAN_HPP_INLINE void CommandBuffer::setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
13107  {
13108  getDispatcher()->vkCmdSetCullMode( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) );
13109  }
13110 
13111  VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
13112  {
13113  getDispatcher()->vkCmdSetFrontFace( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) );
13114  }
13115 
13116  VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
13117  {
13118  getDispatcher()->vkCmdSetPrimitiveTopology( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) );
13119  }
13120 
13121  VULKAN_HPP_INLINE void
13122  CommandBuffer::setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
13123  {
13124  getDispatcher()->vkCmdSetViewportWithCount(
13125  static_cast<VkCommandBuffer>( m_commandBuffer ), viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
13126  }
13127 
13128  VULKAN_HPP_INLINE void
13129  CommandBuffer::setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
13130  {
13131  getDispatcher()->vkCmdSetScissorWithCount(
13132  static_cast<VkCommandBuffer>( m_commandBuffer ), scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
13133  }
13134 
13135  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding,
13140  {
13141  if ( buffers.size() != offsets.size() )
13142  {
13143  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" );
13144  }
13145  if ( !sizes.empty() && buffers.size() != sizes.size() )
13146  {
13147  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()" );
13148  }
13149  if ( !strides.empty() && buffers.size() != strides.size() )
13150  {
13151  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()" );
13152  }
13153 
13154  getDispatcher()->vkCmdBindVertexBuffers2( static_cast<VkCommandBuffer>( m_commandBuffer ),
13155  firstBinding,
13156  buffers.size(),
13157  reinterpret_cast<const VkBuffer *>( buffers.data() ),
13158  reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
13159  reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
13160  reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
13161  }
13162 
13163  VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
13164  {
13165  getDispatcher()->vkCmdSetDepthTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) );
13166  }
13167 
13168  VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
13169  {
13170  getDispatcher()->vkCmdSetDepthWriteEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) );
13171  }
13172 
13173  VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
13174  {
13175  getDispatcher()->vkCmdSetDepthCompareOp( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) );
13176  }
13177 
13178  VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
13179  {
13180  getDispatcher()->vkCmdSetDepthBoundsTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) );
13181  }
13182 
13183  VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
13184  {
13185  getDispatcher()->vkCmdSetStencilTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) );
13186  }
13187 
13188  VULKAN_HPP_INLINE void CommandBuffer::setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
13191  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
13192  VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
13193  {
13194  getDispatcher()->vkCmdSetStencilOp( static_cast<VkCommandBuffer>( m_commandBuffer ),
13195  static_cast<VkStencilFaceFlags>( faceMask ),
13196  static_cast<VkStencilOp>( failOp ),
13197  static_cast<VkStencilOp>( passOp ),
13198  static_cast<VkStencilOp>( depthFailOp ),
13199  static_cast<VkCompareOp>( compareOp ) );
13200  }
13201 
13202  VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
13203  {
13204  getDispatcher()->vkCmdSetRasterizerDiscardEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) );
13205  }
13206 
13207  VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
13208  {
13209  getDispatcher()->vkCmdSetDepthBiasEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) );
13210  }
13211 
13212  VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
13213  {
13214  getDispatcher()->vkCmdSetPrimitiveRestartEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) );
13215  }
13216 
13218  Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
13219  {
13220  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
13221  getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
13222  reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
13223  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13224 
13225  return memoryRequirements;
13226  }
13227 
13228  template <typename X, typename Y, typename... Z>
13230  Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
13231  {
13232  StructureChain<X, Y, Z...> structureChain;
13233  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
13234  getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
13235  reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
13236  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13237 
13238  return structureChain;
13239  }
13240 
13242  Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
13243  {
13244  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
13245  getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast<VkDevice>( m_device ),
13246  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
13247  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13248 
13249  return memoryRequirements;
13250  }
13251 
13252  template <typename X, typename Y, typename... Z>
13254  Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
13255  {
13256  StructureChain<X, Y, Z...> structureChain;
13257  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
13258  getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast<VkDevice>( m_device ),
13259  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
13260  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13261 
13262  return structureChain;
13263  }
13264 
13265  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
13266  Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const
13267  {
13268  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
13269  uint32_t sparseMemoryRequirementCount;
13270  getDispatcher()->vkGetDeviceImageSparseMemoryRequirements(
13271  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
13272  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
13273  getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ),
13274  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
13275  &sparseMemoryRequirementCount,
13276  reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
13277 
13278  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
13279  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
13280  {
13281  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
13282  }
13283  return sparseMemoryRequirements;
13284  }
13285 
13286  //=== VK_KHR_surface ===
13287 
13288  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex,
13289  VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
13290  {
13292  "Function <vkGetPhysicalDeviceSurfaceSupportKHR> needs extension <VK_KHR_surface> enabled!" );
13293 
13294  VULKAN_HPP_NAMESPACE::Bool32 supported;
13295  VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR(
13296  static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32 *>( &supported ) );
13297  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" );
13298 
13299  return supported;
13300  }
13301 
13303  PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
13304  {
13306  "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> needs extension <VK_KHR_surface> enabled!" );
13307 
13309  VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13310  static_cast<VkSurfaceKHR>( surface ),
13311  reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) );
13312  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" );
13313 
13314  return surfaceCapabilities;
13315  }
13316 
13317  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
13318  PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
13319  {
13321  "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> needs extension <VK_KHR_surface> enabled!" );
13322 
13323  std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> surfaceFormats;
13324  uint32_t surfaceFormatCount;
13325  VkResult result;
13326  do
13327  {
13328  result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR(
13329  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr );
13330  if ( ( result == VK_SUCCESS ) && surfaceFormatCount )
13331  {
13332  surfaceFormats.resize( surfaceFormatCount );
13333  result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13334  static_cast<VkSurfaceKHR>( surface ),
13335  &surfaceFormatCount,
13336  reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) );
13337  }
13338  } while ( result == VK_INCOMPLETE );
13339  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
13340  VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
13341  if ( surfaceFormatCount < surfaceFormats.size() )
13342  {
13343  surfaceFormats.resize( surfaceFormatCount );
13344  }
13345  return surfaceFormats;
13346  }
13347 
13348  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
13349  PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
13350  {
13352  "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> needs extension <VK_KHR_surface> enabled!" );
13353 
13354  std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
13355  uint32_t presentModeCount;
13356  VkResult result;
13357  do
13358  {
13359  result = getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR(
13360  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr );
13361  if ( ( result == VK_SUCCESS ) && presentModeCount )
13362  {
13363  presentModes.resize( presentModeCount );
13364  result = getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13365  static_cast<VkSurfaceKHR>( surface ),
13366  &presentModeCount,
13367  reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) );
13368  }
13369  } while ( result == VK_INCOMPLETE );
13370  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
13371  VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
13372  if ( presentModeCount < presentModes.size() )
13373  {
13374  presentModes.resize( presentModeCount );
13375  }
13376  return presentModes;
13377  }
13378 
13379  //=== VK_KHR_swapchain ===
13380 
13382  Device::createSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,
13384  {
13385  return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, createInfo, allocator );
13386  }
13387 
13388  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Image> SwapchainKHR::getImages() const
13389  {
13390  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> needs extension <VK_KHR_swapchain> enabled!" );
13391 
13392  std::vector<VULKAN_HPP_NAMESPACE::Image> swapchainImages;
13393  uint32_t swapchainImageCount;
13394  VkResult result;
13395  do
13396  {
13397  result = getDispatcher()->vkGetSwapchainImagesKHR(
13398  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), &swapchainImageCount, nullptr );
13399  if ( ( result == VK_SUCCESS ) && swapchainImageCount )
13400  {
13401  swapchainImages.resize( swapchainImageCount );
13402  result = getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ),
13403  static_cast<VkSwapchainKHR>( m_swapchain ),
13404  &swapchainImageCount,
13405  reinterpret_cast<VkImage *>( swapchainImages.data() ) );
13406  }
13407  } while ( result == VK_INCOMPLETE );
13408  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getImages" );
13409  VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
13410  if ( swapchainImageCount < swapchainImages.size() )
13411  {
13412  swapchainImages.resize( swapchainImageCount );
13413  }
13414  return swapchainImages;
13415  }
13416 
13417  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
13418  SwapchainKHR::acquireNextImage( uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence ) const
13419  {
13420  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImageKHR && "Function <vkAcquireNextImageKHR> needs extension <VK_KHR_swapchain> enabled!" );
13421 
13422  uint32_t imageIndex;
13423  VkResult result = getDispatcher()->vkAcquireNextImageKHR( static_cast<VkDevice>( m_device ),
13424  static_cast<VkSwapchainKHR>( m_swapchain ),
13425  timeout,
13426  static_cast<VkSemaphore>( semaphore ),
13427  static_cast<VkFence>( fence ),
13428  &imageIndex );
13429  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
13430  VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage",
13435 
13436  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex );
13437  }
13438 
13440  {
13441  VULKAN_HPP_ASSERT( getDispatcher()->vkQueuePresentKHR && "Function <vkQueuePresentKHR> needs extension <VK_KHR_swapchain> enabled!" );
13442 
13443  VkResult result = getDispatcher()->vkQueuePresentKHR( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) );
13444  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
13445  VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR",
13447 
13448  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
13449  }
13450 
13452  {
13454  "Function <vkGetDeviceGroupPresentCapabilitiesKHR> needs extension <VK_KHR_swapchain> enabled!" );
13455 
13456  VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
13457  VkResult result = getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR(
13458  static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) );
13459  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" );
13460 
13461  return deviceGroupPresentCapabilities;
13462  }
13463 
13465  Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
13466  {
13468  "Function <vkGetDeviceGroupSurfacePresentModesKHR> needs extension <VK_KHR_swapchain> enabled!" );
13469 
13471  VkResult result = getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR(
13472  static_cast<VkDevice>( m_device ), static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) );
13473  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" );
13474 
13475  return modes;
13476  }
13477 
13478  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Rect2D>
13479  PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
13480  {
13482  "Function <vkGetPhysicalDevicePresentRectanglesKHR> needs extension <VK_KHR_swapchain> enabled!" );
13483 
13484  std::vector<VULKAN_HPP_NAMESPACE::Rect2D> rects;
13485  uint32_t rectCount;
13486  VkResult result;
13487  do
13488  {
13489  result = getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR(
13490  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr );
13491  if ( ( result == VK_SUCCESS ) && rectCount )
13492  {
13493  rects.resize( rectCount );
13494  result = getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR(
13495  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D *>( rects.data() ) );
13496  }
13497  } while ( result == VK_INCOMPLETE );
13498  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" );
13499  VULKAN_HPP_ASSERT( rectCount <= rects.size() );
13500  if ( rectCount < rects.size() )
13501  {
13502  rects.resize( rectCount );
13503  }
13504  return rects;
13505  }
13506 
13507  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
13508  Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo ) const
13509  {
13510  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImage2KHR && "Function <vkAcquireNextImage2KHR> needs extension <VK_KHR_swapchain> enabled!" );
13511 
13512  uint32_t imageIndex;
13513  VkResult result = getDispatcher()->vkAcquireNextImage2KHR(
13514  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ), &imageIndex );
13515  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
13516  VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR",
13521 
13522  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex );
13523  }
13524 
13525  //=== VK_KHR_display ===
13526 
13527  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> PhysicalDevice::getDisplayPropertiesKHR() const
13528  {
13530  "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> needs extension <VK_KHR_display> enabled!" );
13531 
13532  std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> properties;
13533  uint32_t propertyCount;
13534  VkResult result;
13535  do
13536  {
13537  result = getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr );
13538  if ( ( result == VK_SUCCESS ) && propertyCount )
13539  {
13540  properties.resize( propertyCount );
13541  result = getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR(
13542  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) );
13543  }
13544  } while ( result == VK_INCOMPLETE );
13545  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
13546  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
13547  if ( propertyCount < properties.size() )
13548  {
13549  properties.resize( propertyCount );
13550  }
13551  return properties;
13552  }
13553 
13554  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> PhysicalDevice::getDisplayPlanePropertiesKHR() const
13555  {
13557  "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> needs extension <VK_KHR_display> enabled!" );
13558 
13559  std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> properties;
13560  uint32_t propertyCount;
13561  VkResult result;
13562  do
13563  {
13564  result = getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr );
13565  if ( ( result == VK_SUCCESS ) && propertyCount )
13566  {
13567  properties.resize( propertyCount );
13568  result = getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
13569  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) );
13570  }
13571  } while ( result == VK_INCOMPLETE );
13572  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
13573  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
13574  if ( propertyCount < properties.size() )
13575  {
13576  properties.resize( propertyCount );
13577  }
13578  return properties;
13579  }
13580 
13581  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>
13582  PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const
13583  {
13584  return VULKAN_HPP_RAII_NAMESPACE::DisplayKHRs( *this, planeIndex );
13585  }
13586 
13587  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> DisplayKHR::getModeProperties() const
13588  {
13590  "Function <vkGetDisplayModePropertiesKHR> needs extension <VK_KHR_display> enabled!" );
13591 
13592  std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> properties;
13593  uint32_t propertyCount;
13594  VkResult result;
13595  do
13596  {
13597  result = getDispatcher()->vkGetDisplayModePropertiesKHR(
13598  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ), &propertyCount, nullptr );
13599  if ( ( result == VK_SUCCESS ) && propertyCount )
13600  {
13601  properties.resize( propertyCount );
13602  result = getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13603  static_cast<VkDisplayKHR>( m_display ),
13604  &propertyCount,
13605  reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) );
13606  }
13607  } while ( result == VK_INCOMPLETE );
13608  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties" );
13609  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
13610  if ( propertyCount < properties.size() )
13611  {
13612  properties.resize( propertyCount );
13613  }
13614  return properties;
13615  }
13616 
13618  DisplayKHR::createMode( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo,
13620  {
13621  return VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR( *this, createInfo, allocator );
13622  }
13623 
13625  DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex ) const
13626  {
13628  "Function <vkGetDisplayPlaneCapabilitiesKHR> needs extension <VK_KHR_display> enabled!" );
13629 
13631  VkResult result = getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13632  static_cast<VkDisplayModeKHR>( m_displayModeKHR ),
13633  planeIndex,
13634  reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) );
13635  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" );
13636 
13637  return capabilities;
13638  }
13639 
13641  Instance::createDisplayPlaneSurfaceKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo,
13643  {
13644  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
13645  }
13646 
13647  //=== VK_KHR_display_swapchain ===
13648 
13649  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>
13650  Device::createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
13652  {
13653  return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHRs( *this, createInfos, allocator );
13654  }
13655 
13657  Device::createSharedSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,
13659  {
13660  return VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, createInfo, allocator );
13661  }
13662 
13663 # if defined( VK_USE_PLATFORM_XLIB_KHR )
13664  //=== VK_KHR_xlib_surface ===
13665 
13667  Instance::createXlibSurfaceKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo,
13669  {
13670  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
13671  }
13672 
13674  PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT
13675  {
13677  "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> needs extension <VK_KHR_xlib_surface> enabled!" );
13678 
13679  VkBool32 result =
13680  getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dpy, visualID );
13681 
13682  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
13683  }
13684 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
13685 
13686 # if defined( VK_USE_PLATFORM_XCB_KHR )
13687  //=== VK_KHR_xcb_surface ===
13688 
13689  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR
13690  Instance::createXcbSurfaceKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo,
13692  {
13693  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
13694  }
13695 
13696  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR(
13697  uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT
13698  {
13700  "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> needs extension <VK_KHR_xcb_surface> enabled!" );
13701 
13702  VkBool32 result = getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR(
13703  static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &connection, visual_id );
13704 
13705  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
13706  }
13707 # endif /*VK_USE_PLATFORM_XCB_KHR*/
13708 
13709 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
13710  //=== VK_KHR_wayland_surface ===
13711 
13712  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR
13713  Instance::createWaylandSurfaceKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo,
13715  {
13716  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
13717  }
13718 
13720  PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const VULKAN_HPP_NOEXCEPT
13721  {
13723  "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> needs extension <VK_KHR_wayland_surface> enabled!" );
13724 
13725  VkBool32 result =
13726  getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &display );
13727 
13728  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
13729  }
13730 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
13731 
13732 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
13733  //=== VK_KHR_android_surface ===
13734 
13735  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR
13736  Instance::createAndroidSurfaceKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo,
13738  {
13739  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
13740  }
13741 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
13742 
13743 # if defined( VK_USE_PLATFORM_WIN32_KHR )
13744  //=== VK_KHR_win32_surface ===
13745 
13746  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR
13747  Instance::createWin32SurfaceKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo,
13749  {
13750  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
13751  }
13752 
13754  PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
13755  {
13757  "Function <vkGetPhysicalDeviceWin32PresentationSupportKHR> needs extension <VK_KHR_win32_surface> enabled!" );
13758 
13759  VkBool32 result = getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex );
13760 
13761  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
13762  }
13763 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
13764 
13765  //=== VK_EXT_debug_report ===
13766 
13767  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT
13768  Instance::createDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo,
13770  {
13771  return VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT( *this, createInfo, allocator );
13772  }
13773 
13776  uint64_t object,
13777  size_t location,
13778  int32_t messageCode,
13779  const std::string & layerPrefix,
13780  const std::string & message ) const VULKAN_HPP_NOEXCEPT
13781  {
13782  VULKAN_HPP_ASSERT( getDispatcher()->vkDebugReportMessageEXT && "Function <vkDebugReportMessageEXT> needs extension <VK_EXT_debug_report> enabled!" );
13783 
13784  getDispatcher()->vkDebugReportMessageEXT( static_cast<VkInstance>( m_instance ),
13785  static_cast<VkDebugReportFlagsEXT>( flags ),
13786  static_cast<VkDebugReportObjectTypeEXT>( objectType_ ),
13787  object,
13788  location,
13789  messageCode,
13790  layerPrefix.c_str(),
13791  message.c_str() );
13792  }
13793 
13794  //=== VK_EXT_debug_marker ===
13795 
13796  VULKAN_HPP_INLINE void Device::debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo ) const
13797  {
13798  VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectTagEXT &&
13799  "Function <vkDebugMarkerSetObjectTagEXT> needs extension <VK_EXT_debug_marker> enabled!" );
13800 
13801  VkResult result =
13802  getDispatcher()->vkDebugMarkerSetObjectTagEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) );
13803  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" );
13804  }
13805 
13806  VULKAN_HPP_INLINE void Device::debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo ) const
13807  {
13809  "Function <vkDebugMarkerSetObjectNameEXT> needs extension <VK_EXT_debug_marker> enabled!" );
13810 
13811  VkResult result = getDispatcher()->vkDebugMarkerSetObjectNameEXT( static_cast<VkDevice>( m_device ),
13812  reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) );
13813  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" );
13814  }
13815 
13816  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT
13817  {
13818  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerBeginEXT && "Function <vkCmdDebugMarkerBeginEXT> needs extension <VK_EXT_debug_marker> enabled!" );
13819 
13820  getDispatcher()->vkCmdDebugMarkerBeginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
13821  reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
13822  }
13823 
13824  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT
13825  {
13826  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerEndEXT && "Function <vkCmdDebugMarkerEndEXT> needs extension <VK_EXT_debug_marker> enabled!" );
13827 
13828  getDispatcher()->vkCmdDebugMarkerEndEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
13829  }
13830 
13831  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT
13832  {
13833  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerInsertEXT && "Function <vkCmdDebugMarkerInsertEXT> needs extension <VK_EXT_debug_marker> enabled!" );
13834 
13835  getDispatcher()->vkCmdDebugMarkerInsertEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
13836  reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
13837  }
13838 
13839 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13840  //=== VK_KHR_video_queue ===
13841 
13842  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR
13843  PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const
13844  {
13846  "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
13847 
13848  VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities;
13849  VkResult result = getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13850  reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ),
13851  reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) );
13852  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
13853 
13854  return capabilities;
13855  }
13856 
13857  template <typename X, typename Y, typename... Z>
13859  PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const
13860  {
13862  "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
13863 
13864  StructureChain<X, Y, Z...> structureChain;
13865  VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>();
13866  VkResult result = getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13867  reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ),
13868  reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) );
13869  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
13870 
13871  return structureChain;
13872  }
13873 
13874  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
13875  PhysicalDevice::getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const
13876  {
13878  "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
13879 
13880  std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> videoFormatProperties;
13881  uint32_t videoFormatPropertyCount;
13882  VkResult result;
13883  do
13884  {
13885  result = getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13886  reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
13887  &videoFormatPropertyCount,
13888  nullptr );
13889  if ( ( result == VK_SUCCESS ) && videoFormatPropertyCount )
13890  {
13891  videoFormatProperties.resize( videoFormatPropertyCount );
13892  result =
13893  getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13894  reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
13895  &videoFormatPropertyCount,
13896  reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) );
13897  }
13898  } while ( result == VK_INCOMPLETE );
13899  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
13900  VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
13901  if ( videoFormatPropertyCount < videoFormatProperties.size() )
13902  {
13903  videoFormatProperties.resize( videoFormatPropertyCount );
13904  }
13905  return videoFormatProperties;
13906  }
13907 
13908  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR
13909  Device::createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,
13911  {
13912  return VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR( *this, createInfo, allocator );
13913  }
13914 
13915  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> VideoSessionKHR::getMemoryRequirements() const
13916  {
13918  "Function <vkGetVideoSessionMemoryRequirementsKHR> needs extension <VK_KHR_video_queue> enabled!" );
13919 
13920  std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> memoryRequirements;
13921  uint32_t memoryRequirementsCount;
13922  VkResult result;
13923  do
13924  {
13925  result = getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR(
13926  static_cast<VkDevice>( m_device ), static_cast<VkVideoSessionKHR>( m_videoSession ), &memoryRequirementsCount, nullptr );
13927  if ( ( result == VK_SUCCESS ) && memoryRequirementsCount )
13928  {
13929  memoryRequirements.resize( memoryRequirementsCount );
13930  result =
13931  getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
13932  static_cast<VkVideoSessionKHR>( m_videoSession ),
13933  &memoryRequirementsCount,
13934  reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) );
13935  }
13936  } while ( result == VK_INCOMPLETE );
13937  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::getMemoryRequirements" );
13938  VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() );
13939  if ( memoryRequirementsCount < memoryRequirements.size() )
13940  {
13941  memoryRequirements.resize( memoryRequirementsCount );
13942  }
13943  return memoryRequirements;
13944  }
13945 
13946  VULKAN_HPP_INLINE void VideoSessionKHR::bindMemory(
13948  {
13949  VULKAN_HPP_ASSERT( getDispatcher()->vkBindVideoSessionMemoryKHR &&
13950  "Function <vkBindVideoSessionMemoryKHR> needs extension <VK_KHR_video_queue> enabled!" );
13951 
13952  VkResult result =
13953  getDispatcher()->vkBindVideoSessionMemoryKHR( static_cast<VkDevice>( m_device ),
13954  static_cast<VkVideoSessionKHR>( m_videoSession ),
13955  bindSessionMemoryInfos.size(),
13956  reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR *>( bindSessionMemoryInfos.data() ) );
13957  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::bindMemory" );
13958  }
13959 
13960  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR
13961  Device::createVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo,
13963  {
13964  return VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR( *this, createInfo, allocator );
13965  }
13966 
13967  VULKAN_HPP_INLINE void VideoSessionParametersKHR::update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const
13968  {
13970  "Function <vkUpdateVideoSessionParametersKHR> needs extension <VK_KHR_video_queue> enabled!" );
13971 
13972  VkResult result = getDispatcher()->vkUpdateVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
13973  static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ),
13974  reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) );
13975  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::VideoSessionParametersKHR::update" );
13976  }
13977 
13978  VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT
13979  {
13980  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginVideoCodingKHR && "Function <vkCmdBeginVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" );
13981 
13982  getDispatcher()->vkCmdBeginVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
13983  reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) );
13984  }
13985 
13986  VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT
13987  {
13988  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndVideoCodingKHR && "Function <vkCmdEndVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" );
13989 
13990  getDispatcher()->vkCmdEndVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
13991  reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) );
13992  }
13993 
13994  VULKAN_HPP_INLINE void
13995  CommandBuffer::controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT
13996  {
13997  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdControlVideoCodingKHR && "Function <vkCmdControlVideoCodingKHR> needs extension <VK_KHR_video_queue> enabled!" );
13998 
13999  getDispatcher()->vkCmdControlVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
14000  reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) );
14001  }
14002 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14003 
14004 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14005  //=== VK_KHR_video_decode_queue ===
14006 
14007  VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT
14008  {
14009  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecodeVideoKHR && "Function <vkCmdDecodeVideoKHR> needs extension <VK_KHR_video_decode_queue> enabled!" );
14010 
14011  getDispatcher()->vkCmdDecodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoDecodeInfoKHR *>( &decodeInfo ) );
14012  }
14013 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
14014 
14015  //=== VK_EXT_transform_feedback ===
14016 
14017  VULKAN_HPP_INLINE void
14018  CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
14022  {
14024  "Function <vkCmdBindTransformFeedbackBuffersEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14025  if ( buffers.size() != offsets.size() )
14026  {
14027  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
14028  }
14029  if ( !sizes.empty() && buffers.size() != sizes.size() )
14030  {
14031  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
14032  }
14033 
14034  getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
14035  firstBinding,
14036  buffers.size(),
14037  reinterpret_cast<const VkBuffer *>( buffers.data() ),
14038  reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
14039  reinterpret_cast<const VkDeviceSize *>( sizes.data() ) );
14040  }
14041 
14042  VULKAN_HPP_INLINE void
14043  CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
14046  {
14048  "Function <vkCmdBeginTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14049  if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
14050  {
14051  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
14052  }
14053 
14054  getDispatcher()->vkCmdBeginTransformFeedbackEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
14055  firstCounterBuffer,
14056  counterBuffers.size(),
14057  reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
14058  reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
14059  }
14060 
14061  VULKAN_HPP_INLINE void
14062  CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer,
14065  {
14066  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndTransformFeedbackEXT &&
14067  "Function <vkCmdEndTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14068  if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
14069  {
14070  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
14071  }
14072 
14073  getDispatcher()->vkCmdEndTransformFeedbackEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
14074  firstCounterBuffer,
14075  counterBuffers.size(),
14076  reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
14077  reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
14078  }
14079 
14080  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
14081  uint32_t query,
14083  uint32_t index ) const VULKAN_HPP_NOEXCEPT
14084  {
14085  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQueryIndexedEXT &&
14086  "Function <vkCmdBeginQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14087 
14088  getDispatcher()->vkCmdBeginQueryIndexedEXT(
14089  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
14090  }
14091 
14092  VULKAN_HPP_INLINE void
14093  CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
14094  {
14095  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQueryIndexedEXT &&
14096  "Function <vkCmdEndQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14097 
14098  getDispatcher()->vkCmdEndQueryIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, index );
14099  }
14100 
14101  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount,
14102  uint32_t firstInstance,
14103  VULKAN_HPP_NAMESPACE::Buffer counterBuffer,
14104  VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
14105  uint32_t counterOffset,
14106  uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT
14107  {
14109  "Function <vkCmdDrawIndirectByteCountEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14110 
14111  getDispatcher()->vkCmdDrawIndirectByteCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
14112  instanceCount,
14113  firstInstance,
14114  static_cast<VkBuffer>( counterBuffer ),
14115  static_cast<VkDeviceSize>( counterBufferOffset ),
14116  counterOffset,
14117  vertexStride );
14118  }
14119 
14120  //=== VK_NVX_binary_import ===
14121 
14123  Device::createCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo,
14125  {
14126  return VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX( *this, createInfo, allocator );
14127  }
14128 
14130  Device::createCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo,
14132  {
14133  return VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX( *this, createInfo, allocator );
14134  }
14135 
14136  VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT
14137  {
14138  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCuLaunchKernelNVX && "Function <vkCmdCuLaunchKernelNVX> needs extension <VK_NVX_binary_import> enabled!" );
14139 
14140  getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
14141  }
14142 
14143  //=== VK_NVX_image_view_handle ===
14144 
14146  Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT
14147  {
14148  VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandleNVX && "Function <vkGetImageViewHandleNVX> needs extension <VK_NVX_image_view_handle> enabled!" );
14149 
14150  uint32_t result =
14151  getDispatcher()->vkGetImageViewHandleNVX( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
14152 
14153  return result;
14154  }
14155 
14157  {
14158  VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX &&
14159  "Function <vkGetImageViewAddressNVX> needs extension <VK_NVX_image_view_handle> enabled!" );
14160 
14162  VkResult result = getDispatcher()->vkGetImageViewAddressNVX(
14163  static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) );
14164  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::ImageView::getAddressNVX" );
14165 
14166  return properties;
14167  }
14168 
14169  //=== VK_AMD_draw_indirect_count ===
14170 
14171  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
14173  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
14174  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
14175  uint32_t maxDrawCount,
14176  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
14177  {
14178  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountAMD &&
14179  "Function <vkCmdDrawIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" );
14180 
14181  getDispatcher()->vkCmdDrawIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
14182  static_cast<VkBuffer>( buffer ),
14183  static_cast<VkDeviceSize>( offset ),
14184  static_cast<VkBuffer>( countBuffer ),
14185  static_cast<VkDeviceSize>( countBufferOffset ),
14186  maxDrawCount,
14187  stride );
14188  }
14189 
14190  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
14192  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
14193  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
14194  uint32_t maxDrawCount,
14195  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
14196  {
14198  "Function <vkCmdDrawIndexedIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" );
14199 
14200  getDispatcher()->vkCmdDrawIndexedIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
14201  static_cast<VkBuffer>( buffer ),
14202  static_cast<VkDeviceSize>( offset ),
14203  static_cast<VkBuffer>( countBuffer ),
14204  static_cast<VkDeviceSize>( countBufferOffset ),
14205  maxDrawCount,
14206  stride );
14207  }
14208 
14209  //=== VK_AMD_shader_info ===
14210 
14211  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> Pipeline::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
14213  {
14214  VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> needs extension <VK_AMD_shader_info> enabled!" );
14215 
14216  std::vector<uint8_t> info;
14217  size_t infoSize;
14218  VkResult result;
14219  do
14220  {
14221  result = getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
14222  static_cast<VkPipeline>( m_pipeline ),
14223  static_cast<VkShaderStageFlagBits>( shaderStage ),
14224  static_cast<VkShaderInfoTypeAMD>( infoType ),
14225  &infoSize,
14226  nullptr );
14227  if ( ( result == VK_SUCCESS ) && infoSize )
14228  {
14229  info.resize( infoSize );
14230  result = getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
14231  static_cast<VkPipeline>( m_pipeline ),
14232  static_cast<VkShaderStageFlagBits>( shaderStage ),
14233  static_cast<VkShaderInfoTypeAMD>( infoType ),
14234  &infoSize,
14235  reinterpret_cast<void *>( info.data() ) );
14236  }
14237  } while ( result == VK_INCOMPLETE );
14238  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getShaderInfoAMD" );
14239  VULKAN_HPP_ASSERT( infoSize <= info.size() );
14240  if ( infoSize < info.size() )
14241  {
14242  info.resize( infoSize );
14243  }
14244  return info;
14245  }
14246 
14247  //=== VK_KHR_dynamic_rendering ===
14248 
14249  VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT
14250  {
14251  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderingKHR && "Function <vkCmdBeginRenderingKHR> needs extension <VK_KHR_dynamic_rendering> enabled!" );
14252 
14253  getDispatcher()->vkCmdBeginRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
14254  }
14255 
14256  VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR() const VULKAN_HPP_NOEXCEPT
14257  {
14258  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderingKHR && "Function <vkCmdEndRenderingKHR> needs extension <VK_KHR_dynamic_rendering> enabled!" );
14259 
14260  getDispatcher()->vkCmdEndRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ) );
14261  }
14262 
14263 # if defined( VK_USE_PLATFORM_GGP )
14264  //=== VK_GGP_stream_descriptor_surface ===
14265 
14267  Instance::createStreamDescriptorSurfaceGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo,
14269  {
14270  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
14271  }
14272 # endif /*VK_USE_PLATFORM_GGP*/
14273 
14274  //=== VK_NV_external_memory_capabilities ===
14275 
14277  PhysicalDevice::getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format,
14283  {
14285  "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> needs extension <VK_NV_external_memory_capabilities> enabled!" );
14286 
14287  VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties;
14288  VkResult result = getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
14289  static_cast<VkPhysicalDevice>( m_physicalDevice ),
14290  static_cast<VkFormat>( format ),
14291  static_cast<VkImageType>( type ),
14292  static_cast<VkImageTiling>( tiling ),
14293  static_cast<VkImageUsageFlags>( usage ),
14294  static_cast<VkImageCreateFlags>( flags ),
14295  static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
14296  reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) );
14297  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" );
14298 
14299  return externalImageFormatProperties;
14300  }
14301 
14302 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14303  //=== VK_NV_external_memory_win32 ===
14304 
14306  {
14307  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleNV &&
14308  "Function <vkGetMemoryWin32HandleNV> needs extension <VK_NV_external_memory_win32> enabled!" );
14309 
14310  HANDLE handle;
14311  VkResult result = getDispatcher()->vkGetMemoryWin32HandleNV(
14312  static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle );
14313  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" );
14314 
14315  return handle;
14316  }
14317 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14318 
14319  //=== VK_KHR_get_physical_device_properties2 ===
14320 
14321  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
14322  {
14324  "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14325 
14327  getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14328  reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
14329 
14330  return features;
14331  }
14332 
14333  template <typename X, typename Y, typename... Z>
14334  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
14335  {
14337  "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14338 
14339  StructureChain<X, Y, Z...> structureChain;
14340  VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
14341  getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14342  reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
14343 
14344  return structureChain;
14345  }
14346 
14347  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT
14348  {
14350  "Function <vkGetPhysicalDeviceProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14351 
14353  getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14354  reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
14355 
14356  return properties;
14357  }
14358 
14359  template <typename X, typename Y, typename... Z>
14360  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT
14361  {
14363  "Function <vkGetPhysicalDeviceProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14364 
14365  StructureChain<X, Y, Z...> structureChain;
14366  VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
14367  getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14368  reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
14369 
14370  return structureChain;
14371  }
14372 
14374  PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
14375  {
14377  "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14378 
14379  VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
14380  getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
14381  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
14382 
14383  return formatProperties;
14384  }
14385 
14386  template <typename X, typename Y, typename... Z>
14388  PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
14389  {
14391  "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14392 
14393  StructureChain<X, Y, Z...> structureChain;
14394  VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
14395  getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
14396  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
14397 
14398  return structureChain;
14399  }
14400 
14402  PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
14403  {
14405  "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14406 
14407  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
14408  VkResult result =
14409  getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14410  reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
14411  reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
14412  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
14413 
14414  return imageFormatProperties;
14415  }
14416 
14417  template <typename X, typename Y, typename... Z>
14419  PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
14420  {
14422  "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14423 
14424  StructureChain<X, Y, Z...> structureChain;
14425  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
14426  VkResult result =
14427  getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14428  reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
14429  reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
14430  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
14431 
14432  return structureChain;
14433  }
14434 
14435  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> PhysicalDevice::getQueueFamilyProperties2KHR() const
14436  {
14438  "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14439 
14440  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
14441  uint32_t queueFamilyPropertyCount;
14442  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
14443  queueFamilyProperties.resize( queueFamilyPropertyCount );
14444  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14445  &queueFamilyPropertyCount,
14446  reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
14447 
14448  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
14449  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
14450  {
14451  queueFamilyProperties.resize( queueFamilyPropertyCount );
14452  }
14453  return queueFamilyProperties;
14454  }
14455 
14456  template <typename StructureChain>
14457  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2KHR() const
14458  {
14460  "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14461 
14462  std::vector<StructureChain> structureChains;
14463  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
14464  uint32_t queueFamilyPropertyCount;
14465  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
14466  structureChains.resize( queueFamilyPropertyCount );
14467  queueFamilyProperties.resize( queueFamilyPropertyCount );
14468  for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
14469  {
14470  queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
14471  }
14472  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14473  &queueFamilyPropertyCount,
14474  reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
14475 
14476  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
14477  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
14478  {
14479  structureChains.resize( queueFamilyPropertyCount );
14480  }
14481  for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
14482  {
14483  structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
14484  }
14485  return structureChains;
14486  }
14487 
14489  PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
14490  {
14492  "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14493 
14495  getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14496  reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
14497 
14498  return memoryProperties;
14499  }
14500 
14501  template <typename X, typename Y, typename... Z>
14502  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
14503  {
14505  "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14506 
14507  StructureChain<X, Y, Z...> structureChain;
14509  structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
14510  getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14511  reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
14512 
14513  return structureChain;
14514  }
14515 
14516  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
14517  PhysicalDevice::getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const
14518  {
14520  "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14521 
14522  std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties;
14523  uint32_t propertyCount;
14524  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14525  reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
14526  &propertyCount,
14527  nullptr );
14528  properties.resize( propertyCount );
14529  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14530  reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
14531  &propertyCount,
14532  reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
14533 
14534  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
14535  if ( propertyCount < properties.size() )
14536  {
14537  properties.resize( propertyCount );
14538  }
14539  return properties;
14540  }
14541 
14542  //=== VK_KHR_device_group ===
14543 
14545  Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT
14546  {
14548  "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> needs extension <VK_KHR_device_group> enabled!" );
14549 
14551  getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR( static_cast<VkDevice>( m_device ),
14552  heapIndex,
14553  localDeviceIndex,
14554  remoteDeviceIndex,
14555  reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
14556 
14557  return peerMemoryFeatures;
14558  }
14559 
14560  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
14561  {
14562  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMaskKHR && "Function <vkCmdSetDeviceMaskKHR> needs extension <VK_KHR_device_group> enabled!" );
14563 
14564  getDispatcher()->vkCmdSetDeviceMaskKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
14565  }
14566 
14567  VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX,
14568  uint32_t baseGroupY,
14569  uint32_t baseGroupZ,
14570  uint32_t groupCountX,
14571  uint32_t groupCountY,
14572  uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
14573  {
14574  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBaseKHR && "Function <vkCmdDispatchBaseKHR> needs extension <VK_KHR_device_group> enabled!" );
14575 
14576  getDispatcher()->vkCmdDispatchBaseKHR(
14577  static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
14578  }
14579 
14580 # if defined( VK_USE_PLATFORM_VI_NN )
14581  //=== VK_NN_vi_surface ===
14582 
14584  Instance::createViSurfaceNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo,
14586  {
14587  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
14588  }
14589 # endif /*VK_USE_PLATFORM_VI_NN*/
14590 
14591  //=== VK_KHR_maintenance1 ===
14592 
14593  VULKAN_HPP_INLINE void CommandPool::trimKHR( VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
14594  {
14595  VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR && "Function <vkTrimCommandPoolKHR> needs extension <VK_KHR_maintenance1> enabled!" );
14596 
14597  getDispatcher()->vkTrimCommandPoolKHR(
14598  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
14599  }
14600 
14601  //=== VK_KHR_device_group_creation ===
14602 
14603  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> Instance::enumeratePhysicalDeviceGroupsKHR() const
14604  {
14606  "Function <vkEnumeratePhysicalDeviceGroupsKHR> needs extension <VK_KHR_device_group_creation> enabled!" );
14607 
14608  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
14609  uint32_t physicalDeviceGroupCount;
14610  VkResult result;
14611  do
14612  {
14613  result = getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr );
14614  if ( ( result == VK_SUCCESS ) && physicalDeviceGroupCount )
14615  {
14616  physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
14617  result =
14618  getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( static_cast<VkInstance>( m_instance ),
14619  &physicalDeviceGroupCount,
14620  reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) );
14621  }
14622  } while ( result == VK_INCOMPLETE );
14623  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
14624  VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
14625  if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
14626  {
14627  physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
14628  }
14629  return physicalDeviceGroupProperties;
14630  }
14631 
14632  //=== VK_KHR_external_memory_capabilities ===
14633 
14635  const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT
14636  {
14638  "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> needs extension <VK_KHR_external_memory_capabilities> enabled!" );
14639 
14640  VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
14641  getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14642  reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
14643  reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
14644 
14645  return externalBufferProperties;
14646  }
14647 
14648 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14649  //=== VK_KHR_external_memory_win32 ===
14650 
14652  Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const
14653  {
14654  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleKHR &&
14655  "Function <vkGetMemoryWin32HandleKHR> needs extension <VK_KHR_external_memory_win32> enabled!" );
14656 
14657  HANDLE handle;
14658  VkResult result = getDispatcher()->vkGetMemoryWin32HandleKHR(
14659  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle );
14660  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" );
14661 
14662  return handle;
14663  }
14664 
14665  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR
14666  Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const
14667  {
14669  "Function <vkGetMemoryWin32HandlePropertiesKHR> needs extension <VK_KHR_external_memory_win32> enabled!" );
14670 
14671  VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
14672  VkResult result =
14673  getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR( static_cast<VkDevice>( m_device ),
14674  static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
14675  handle,
14676  reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) );
14677  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" );
14678 
14679  return memoryWin32HandleProperties;
14680  }
14681 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14682 
14683  //=== VK_KHR_external_memory_fd ===
14684 
14685  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo ) const
14686  {
14687  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdKHR && "Function <vkGetMemoryFdKHR> needs extension <VK_KHR_external_memory_fd> enabled!" );
14688 
14689  int fd;
14690  VkResult result =
14691  getDispatcher()->vkGetMemoryFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd );
14692  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" );
14693 
14694  return fd;
14695  }
14696 
14698  Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd ) const
14699  {
14700  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdPropertiesKHR &&
14701  "Function <vkGetMemoryFdPropertiesKHR> needs extension <VK_KHR_external_memory_fd> enabled!" );
14702 
14704  VkResult result = getDispatcher()->vkGetMemoryFdPropertiesKHR( static_cast<VkDevice>( m_device ),
14705  static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
14706  fd,
14707  reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) );
14708  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" );
14709 
14710  return memoryFdProperties;
14711  }
14712 
14713  //=== VK_KHR_external_semaphore_capabilities ===
14714 
14716  const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
14717  {
14719  "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> needs extension <VK_KHR_external_semaphore_capabilities> enabled!" );
14720 
14721  VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
14722  getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
14723  static_cast<VkPhysicalDevice>( m_physicalDevice ),
14724  reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
14725  reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
14726 
14727  return externalSemaphoreProperties;
14728  }
14729 
14730 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14731  //=== VK_KHR_external_semaphore_win32 ===
14732 
14733  VULKAN_HPP_INLINE void
14734  Device::importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const
14735  {
14737  "Function <vkImportSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" );
14738 
14739  VkResult result = getDispatcher()->vkImportSemaphoreWin32HandleKHR(
14740  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) );
14741  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" );
14742  }
14743 
14745  Device::getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const
14746  {
14747  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreWin32HandleKHR &&
14748  "Function <vkGetSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" );
14749 
14750  HANDLE handle;
14751  VkResult result = getDispatcher()->vkGetSemaphoreWin32HandleKHR(
14752  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle );
14753  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" );
14754 
14755  return handle;
14756  }
14757 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
14758 
14759  //=== VK_KHR_external_semaphore_fd ===
14760 
14761  VULKAN_HPP_INLINE void Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const
14762  {
14763  VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreFdKHR &&
14764  "Function <vkImportSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!" );
14765 
14766  VkResult result = getDispatcher()->vkImportSemaphoreFdKHR( static_cast<VkDevice>( m_device ),
14767  reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) );
14768  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" );
14769  }
14770 
14771  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo ) const
14772  {
14773  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreFdKHR && "Function <vkGetSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!" );
14774 
14775  int fd;
14776  VkResult result =
14777  getDispatcher()->vkGetSemaphoreFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd );
14778  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" );
14779 
14780  return fd;
14781  }
14782 
14783  //=== VK_KHR_push_descriptor ===
14784 
14785  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR(
14786  VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
14788  uint32_t set,
14789  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT
14790  {
14791  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetKHR &&
14792  "Function <vkCmdPushDescriptorSetKHR> needs extension <VK_KHR_push_descriptor> enabled!" );
14793 
14794  getDispatcher()->vkCmdPushDescriptorSetKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
14795  static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
14796  static_cast<VkPipelineLayout>( layout ),
14797  set,
14798  descriptorWrites.size(),
14799  reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) );
14800  }
14801 
14802  template <typename DataType>
14803  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
14805  uint32_t set,
14806  DataType const & data ) const VULKAN_HPP_NOEXCEPT
14807  {
14809  "Function <vkCmdPushDescriptorSetWithTemplateKHR> needs extension <VK_KHR_push_descriptor> enabled!" );
14810 
14811  getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
14812  static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
14813  static_cast<VkPipelineLayout>( layout ),
14814  set,
14815  reinterpret_cast<const void *>( &data ) );
14816  }
14817 
14818  //=== VK_EXT_conditional_rendering ===
14819 
14820  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT(
14821  const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
14822  {
14824  "Function <vkCmdBeginConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" );
14825 
14826  getDispatcher()->vkCmdBeginConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
14827  reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) );
14828  }
14829 
14830  VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT
14831  {
14833  "Function <vkCmdEndConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" );
14834 
14835  getDispatcher()->vkCmdEndConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
14836  }
14837 
14838  //=== VK_KHR_descriptor_update_template ===
14839 
14841  Device::createDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,
14843  {
14844  return VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate( *this, createInfo, allocator );
14845  }
14846 
14847  VULKAN_HPP_INLINE void
14848  Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
14849  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT
14850  {
14852  "Function <vkDestroyDescriptorUpdateTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" );
14853 
14854  getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR(
14855  static_cast<VkDevice>( m_device ),
14856  static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
14857  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
14858  }
14859 
14860  template <typename DataType>
14861  VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
14862  DataType const & data ) const VULKAN_HPP_NOEXCEPT
14863  {
14865  "Function <vkUpdateDescriptorSetWithTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" );
14866 
14867  getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR( static_cast<VkDevice>( m_device ),
14868  static_cast<VkDescriptorSet>( m_descriptorSet ),
14869  static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
14870  reinterpret_cast<const void *>( &data ) );
14871  }
14872 
14873  //=== VK_NV_clip_space_w_scaling ===
14874 
14875  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(
14876  uint32_t firstViewport,
14877  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT
14878  {
14879  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWScalingNV &&
14880  "Function <vkCmdSetViewportWScalingNV> needs extension <VK_NV_clip_space_w_scaling> enabled!" );
14881 
14882  getDispatcher()->vkCmdSetViewportWScalingNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
14883  firstViewport,
14884  viewportWScalings.size(),
14885  reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) );
14886  }
14887 
14888 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
14889  //=== VK_EXT_acquire_xlib_display ===
14890 
14891  VULKAN_HPP_INLINE void PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const
14892  {
14893  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireXlibDisplayEXT &&
14894  "Function <vkAcquireXlibDisplayEXT> needs extension <VK_EXT_acquire_xlib_display> enabled!" );
14895 
14896  VkResult result =
14897  getDispatcher()->vkAcquireXlibDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &dpy, static_cast<VkDisplayKHR>( display ) );
14898  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" );
14899  }
14900 
14901  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR PhysicalDevice::getRandROutputDisplayEXT( Display & dpy,
14902  RROutput rrOutput ) const
14903  {
14904  return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, dpy, rrOutput );
14905  }
14906 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
14907 
14908  //=== VK_EXT_display_surface_counter ===
14909 
14911  PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
14912  {
14914  "Function <vkGetPhysicalDeviceSurfaceCapabilities2EXT> needs extension <VK_EXT_display_surface_counter> enabled!" );
14915 
14917  VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14918  static_cast<VkSurfaceKHR>( surface ),
14919  reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) );
14920  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" );
14921 
14922  return surfaceCapabilities;
14923  }
14924 
14925  //=== VK_EXT_display_control ===
14926 
14927  VULKAN_HPP_INLINE void Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
14928  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo ) const
14929  {
14930  VULKAN_HPP_ASSERT( getDispatcher()->vkDisplayPowerControlEXT && "Function <vkDisplayPowerControlEXT> needs extension <VK_EXT_display_control> enabled!" );
14931 
14932  VkResult result = getDispatcher()->vkDisplayPowerControlEXT(
14933  static_cast<VkDevice>( m_device ), static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) );
14934  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" );
14935  }
14936 
14938  Device::registerEventEXT( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo,
14940  {
14941  return VULKAN_HPP_RAII_NAMESPACE::Fence( *this, deviceEventInfo, allocator );
14942  }
14943 
14945  Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,
14946  VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo,
14948  {
14949  return VULKAN_HPP_RAII_NAMESPACE::Fence( *this, display, displayEventInfo, allocator );
14950  }
14951 
14953  {
14954  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainCounterEXT && "Function <vkGetSwapchainCounterEXT> needs extension <VK_EXT_display_control> enabled!" );
14955 
14956  uint64_t counterValue;
14957  VkResult result = getDispatcher()->vkGetSwapchainCounterEXT(
14958  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue );
14959  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" );
14960 
14961  return counterValue;
14962  }
14963 
14964  //=== VK_GOOGLE_display_timing ===
14965 
14967  {
14969  "Function <vkGetRefreshCycleDurationGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" );
14970 
14971  VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties;
14972  VkResult result = getDispatcher()->vkGetRefreshCycleDurationGOOGLE( static_cast<VkDevice>( m_device ),
14973  static_cast<VkSwapchainKHR>( m_swapchain ),
14974  reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) );
14975  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" );
14976 
14977  return displayTimingProperties;
14978  }
14979 
14980  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> SwapchainKHR::getPastPresentationTimingGOOGLE() const
14981  {
14983  "Function <vkGetPastPresentationTimingGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" );
14984 
14985  std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> presentationTimings;
14986  uint32_t presentationTimingCount;
14987  VkResult result;
14988  do
14989  {
14990  result = getDispatcher()->vkGetPastPresentationTimingGOOGLE(
14991  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), &presentationTimingCount, nullptr );
14992  if ( ( result == VK_SUCCESS ) && presentationTimingCount )
14993  {
14994  presentationTimings.resize( presentationTimingCount );
14995  result = getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast<VkDevice>( m_device ),
14996  static_cast<VkSwapchainKHR>( m_swapchain ),
14997  &presentationTimingCount,
14998  reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) );
14999  }
15000  } while ( result == VK_INCOMPLETE );
15001  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE" );
15002  VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
15003  if ( presentationTimingCount < presentationTimings.size() )
15004  {
15005  presentationTimings.resize( presentationTimingCount );
15006  }
15007  return presentationTimings;
15008  }
15009 
15010  //=== VK_EXT_discard_rectangles ===
15011 
15012  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT(
15013  uint32_t firstDiscardRectangle, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT
15014  {
15015  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleEXT &&
15016  "Function <vkCmdSetDiscardRectangleEXT> needs extension <VK_EXT_discard_rectangles> enabled!" );
15017 
15018  getDispatcher()->vkCmdSetDiscardRectangleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15019  firstDiscardRectangle,
15020  discardRectangles.size(),
15021  reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) );
15022  }
15023 
15024  //=== VK_EXT_hdr_metadata ===
15025 
15028  {
15029  VULKAN_HPP_ASSERT( getDispatcher()->vkSetHdrMetadataEXT && "Function <vkSetHdrMetadataEXT> needs extension <VK_EXT_hdr_metadata> enabled!" );
15030  if ( swapchains.size() != metadata.size() )
15031  {
15032  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
15033  }
15034 
15035  getDispatcher()->vkSetHdrMetadataEXT( static_cast<VkDevice>( m_device ),
15036  swapchains.size(),
15037  reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ),
15038  reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) );
15039  }
15040 
15041  //=== VK_KHR_create_renderpass2 ===
15042 
15044  Device::createRenderPass2KHR( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,
15046  {
15047  return VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, createInfo, allocator );
15048  }
15049 
15050  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
15051  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
15052  {
15053  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2KHR &&
15054  "Function <vkCmdBeginRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
15055 
15056  getDispatcher()->vkCmdBeginRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15057  reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
15058  reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
15059  }
15060 
15061  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
15062  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
15063  {
15064  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2KHR && "Function <vkCmdNextSubpass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
15065 
15066  getDispatcher()->vkCmdNextSubpass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15067  reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
15068  reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
15069  }
15070 
15071  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
15072  {
15073  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2KHR && "Function <vkCmdEndRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
15074 
15075  getDispatcher()->vkCmdEndRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
15076  }
15077 
15078  //=== VK_KHR_shared_presentable_image ===
15079 
15081  {
15082  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainStatusKHR &&
15083  "Function <vkGetSwapchainStatusKHR> needs extension <VK_KHR_shared_presentable_image> enabled!" );
15084 
15085  VkResult result = getDispatcher()->vkGetSwapchainStatusKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) );
15086  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
15087  VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus",
15089 
15090  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
15091  }
15092 
15093  //=== VK_KHR_external_fence_capabilities ===
15094 
15096  PhysicalDevice::getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT
15097  {
15099  "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> needs extension <VK_KHR_external_fence_capabilities> enabled!" );
15100 
15101  VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
15102  getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15103  reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
15104  reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
15105 
15106  return externalFenceProperties;
15107  }
15108 
15109 # if defined( VK_USE_PLATFORM_WIN32_KHR )
15110  //=== VK_KHR_external_fence_win32 ===
15111 
15112  VULKAN_HPP_INLINE void Device::importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const
15113  {
15114  VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceWin32HandleKHR &&
15115  "Function <vkImportFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" );
15116 
15117  VkResult result = getDispatcher()->vkImportFenceWin32HandleKHR(
15118  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) );
15119  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" );
15120  }
15121 
15123  Device::getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const
15124  {
15125  VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceWin32HandleKHR &&
15126  "Function <vkGetFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" );
15127 
15128  HANDLE handle;
15129  VkResult result = getDispatcher()->vkGetFenceWin32HandleKHR(
15130  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle );
15131  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" );
15132 
15133  return handle;
15134  }
15135 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
15136 
15137  //=== VK_KHR_external_fence_fd ===
15138 
15139  VULKAN_HPP_INLINE void Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo ) const
15140  {
15141  VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceFdKHR && "Function <vkImportFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!" );
15142 
15143  VkResult result =
15144  getDispatcher()->vkImportFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) );
15145  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" );
15146  }
15147 
15148  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo ) const
15149  {
15150  VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceFdKHR && "Function <vkGetFenceFdKHR> needs extension <VK_KHR_external_fence_fd> enabled!" );
15151 
15152  int fd;
15153  VkResult result = getDispatcher()->vkGetFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd );
15154  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" );
15155 
15156  return fd;
15157  }
15158 
15159  //=== VK_KHR_performance_query ===
15160 
15162  VULKAN_HPP_INLINE std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>>
15163  PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const
15164  {
15166  "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> needs extension <VK_KHR_performance_query> enabled!" );
15167 
15168  std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>> data;
15169  std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> & counters = data.first;
15170  std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> & counterDescriptions = data.second;
15171  uint32_t counterCount;
15172  VkResult result;
15173  do
15174  {
15175  result = getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
15176  static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr );
15177  if ( ( result == VK_SUCCESS ) && counterCount )
15178  {
15179  counters.resize( counterCount );
15180  counterDescriptions.resize( counterCount );
15181  result = getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
15182  static_cast<VkPhysicalDevice>( m_physicalDevice ),
15183  queueFamilyIndex,
15184  &counterCount,
15185  reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
15186  reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) );
15187  }
15188  } while ( result == VK_INCOMPLETE );
15189  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
15190  VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
15191  VULKAN_HPP_ASSERT( counterCount <= counters.size() );
15192  if ( counterCount < counters.size() )
15193  {
15194  counters.resize( counterCount );
15195  counterDescriptions.resize( counterCount );
15196  }
15197  return data;
15198  }
15199 
15200  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
15201  const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT
15202  {
15204  "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> needs extension <VK_KHR_performance_query> enabled!" );
15205 
15206  uint32_t numPasses;
15207  getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
15208  static_cast<VkPhysicalDevice>( m_physicalDevice ),
15209  reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ),
15210  &numPasses );
15211 
15212  return numPasses;
15213  }
15214 
15215  VULKAN_HPP_INLINE void Device::acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info ) const
15216  {
15217  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireProfilingLockKHR &&
15218  "Function <vkAcquireProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" );
15219 
15220  VkResult result =
15221  getDispatcher()->vkAcquireProfilingLockKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) );
15222  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" );
15223  }
15224 
15225  VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT
15226  {
15227  VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseProfilingLockKHR &&
15228  "Function <vkReleaseProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" );
15229 
15230  getDispatcher()->vkReleaseProfilingLockKHR( static_cast<VkDevice>( m_device ) );
15231  }
15232 
15233  //=== VK_KHR_get_surface_capabilities2 ===
15234 
15236  PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
15237  {
15239  "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" );
15240 
15242  VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15243  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15244  reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) );
15245  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
15246 
15247  return surfaceCapabilities;
15248  }
15249 
15250  template <typename X, typename Y, typename... Z>
15252  PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
15253  {
15255  "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" );
15256 
15257  StructureChain<X, Y, Z...> structureChain;
15258  VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>();
15259  VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15260  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15261  reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) );
15262  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
15263 
15264  return structureChain;
15265  }
15266 
15267  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
15268  PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
15269  {
15271  "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" );
15272 
15273  std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats;
15274  uint32_t surfaceFormatCount;
15275  VkResult result;
15276  do
15277  {
15278  result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15279  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15280  &surfaceFormatCount,
15281  nullptr );
15282  if ( ( result == VK_SUCCESS ) && surfaceFormatCount )
15283  {
15284  surfaceFormats.resize( surfaceFormatCount );
15285  result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15286  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15287  &surfaceFormatCount,
15288  reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) );
15289  }
15290  } while ( result == VK_INCOMPLETE );
15291  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
15292  VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
15293  if ( surfaceFormatCount < surfaceFormats.size() )
15294  {
15295  surfaceFormats.resize( surfaceFormatCount );
15296  }
15297  return surfaceFormats;
15298  }
15299 
15300  template <typename StructureChain>
15301  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain>
15302  PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
15303  {
15305  "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" );
15306 
15307  std::vector<StructureChain> structureChains;
15308  std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats;
15309  uint32_t surfaceFormatCount;
15310  VkResult result;
15311  do
15312  {
15313  result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15314  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15315  &surfaceFormatCount,
15316  nullptr );
15317  if ( ( result == VK_SUCCESS ) && surfaceFormatCount )
15318  {
15319  structureChains.resize( surfaceFormatCount );
15320  surfaceFormats.resize( surfaceFormatCount );
15321  for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
15322  {
15323  surfaceFormats[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>().pNext;
15324  }
15325  result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15326  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15327  &surfaceFormatCount,
15328  reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) );
15329  }
15330  } while ( result == VK_INCOMPLETE );
15331  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
15332  VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
15333  if ( surfaceFormatCount < surfaceFormats.size() )
15334  {
15335  structureChains.resize( surfaceFormatCount );
15336  }
15337  for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
15338  {
15339  structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>() = surfaceFormats[i];
15340  }
15341  return structureChains;
15342  }
15343 
15344  //=== VK_KHR_get_display_properties2 ===
15345 
15346  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> PhysicalDevice::getDisplayProperties2KHR() const
15347  {
15349  "Function <vkGetPhysicalDeviceDisplayProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
15350 
15351  std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> properties;
15352  uint32_t propertyCount;
15353  VkResult result;
15354  do
15355  {
15356  result = getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr );
15357  if ( ( result == VK_SUCCESS ) && propertyCount )
15358  {
15359  properties.resize( propertyCount );
15360  result = getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR(
15361  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) );
15362  }
15363  } while ( result == VK_INCOMPLETE );
15364  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
15365  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15366  if ( propertyCount < properties.size() )
15367  {
15368  properties.resize( propertyCount );
15369  }
15370  return properties;
15371  }
15372 
15373  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> PhysicalDevice::getDisplayPlaneProperties2KHR() const
15374  {
15376  "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
15377 
15378  std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> properties;
15379  uint32_t propertyCount;
15380  VkResult result;
15381  do
15382  {
15383  result = getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr );
15384  if ( ( result == VK_SUCCESS ) && propertyCount )
15385  {
15386  properties.resize( propertyCount );
15387  result = getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
15388  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) );
15389  }
15390  } while ( result == VK_INCOMPLETE );
15391  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
15392  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15393  if ( propertyCount < properties.size() )
15394  {
15395  properties.resize( propertyCount );
15396  }
15397  return properties;
15398  }
15399 
15400  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> DisplayKHR::getModeProperties2() const
15401  {
15403  "Function <vkGetDisplayModeProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
15404 
15405  std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> properties;
15406  uint32_t propertyCount;
15407  VkResult result;
15408  do
15409  {
15410  result = getDispatcher()->vkGetDisplayModeProperties2KHR(
15411  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ), &propertyCount, nullptr );
15412  if ( ( result == VK_SUCCESS ) && propertyCount )
15413  {
15414  properties.resize( propertyCount );
15415  result = getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15416  static_cast<VkDisplayKHR>( m_display ),
15417  &propertyCount,
15418  reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) );
15419  }
15420  } while ( result == VK_INCOMPLETE );
15421  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" );
15422  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15423  if ( propertyCount < properties.size() )
15424  {
15425  properties.resize( propertyCount );
15426  }
15427  return properties;
15428  }
15429 
15431  PhysicalDevice::getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const
15432  {
15434  "Function <vkGetDisplayPlaneCapabilities2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
15435 
15437  VkResult result = getDispatcher()->vkGetDisplayPlaneCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15438  reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ),
15439  reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) );
15440  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
15441 
15442  return capabilities;
15443  }
15444 
15445 # if defined( VK_USE_PLATFORM_IOS_MVK )
15446  //=== VK_MVK_ios_surface ===
15447 
15449  Instance::createIOSSurfaceMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo,
15451  {
15452  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
15453  }
15454 # endif /*VK_USE_PLATFORM_IOS_MVK*/
15455 
15456 # if defined( VK_USE_PLATFORM_MACOS_MVK )
15457  //=== VK_MVK_macos_surface ===
15458 
15460  Instance::createMacOSSurfaceMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo,
15462  {
15463  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
15464  }
15465 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
15466 
15467  //=== VK_EXT_debug_utils ===
15468 
15469  VULKAN_HPP_INLINE void Device::setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo ) const
15470  {
15471  VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectNameEXT &&
15472  "Function <vkSetDebugUtilsObjectNameEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15473 
15474  VkResult result = getDispatcher()->vkSetDebugUtilsObjectNameEXT( static_cast<VkDevice>( m_device ),
15475  reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) );
15476  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" );
15477  }
15478 
15479  VULKAN_HPP_INLINE void Device::setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo ) const
15480  {
15481  VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectTagEXT &&
15482  "Function <vkSetDebugUtilsObjectTagEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15483 
15484  VkResult result =
15485  getDispatcher()->vkSetDebugUtilsObjectTagEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) );
15486  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" );
15487  }
15488 
15489  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
15490  {
15492  "Function <vkQueueBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15493 
15494  getDispatcher()->vkQueueBeginDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
15495  }
15496 
15497  VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT
15498  {
15499  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueEndDebugUtilsLabelEXT &&
15500  "Function <vkQueueEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15501 
15502  getDispatcher()->vkQueueEndDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ) );
15503  }
15504 
15505  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
15506  {
15508  "Function <vkQueueInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15509 
15510  getDispatcher()->vkQueueInsertDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
15511  }
15512 
15513  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
15514  {
15515  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginDebugUtilsLabelEXT &&
15516  "Function <vkCmdBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15517 
15518  getDispatcher()->vkCmdBeginDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15519  reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
15520  }
15521 
15522  VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT
15523  {
15524  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndDebugUtilsLabelEXT && "Function <vkCmdEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15525 
15526  getDispatcher()->vkCmdEndDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
15527  }
15528 
15529  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
15530  {
15532  "Function <vkCmdInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15533 
15534  getDispatcher()->vkCmdInsertDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15535  reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
15536  }
15537 
15539  Instance::createDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo,
15541  {
15542  return VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT( *this, createInfo, allocator );
15543  }
15544 
15545  VULKAN_HPP_INLINE void
15546  Instance::submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
15548  const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT
15549  {
15550  VULKAN_HPP_ASSERT( getDispatcher()->vkSubmitDebugUtilsMessageEXT &&
15551  "Function <vkSubmitDebugUtilsMessageEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15552 
15553  getDispatcher()->vkSubmitDebugUtilsMessageEXT( static_cast<VkInstance>( m_instance ),
15554  static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
15555  static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
15556  reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) );
15557  }
15558 
15559 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
15560  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
15561 
15562  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID
15563  Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const
15564  {
15567  "Function <vkGetAndroidHardwareBufferPropertiesANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
15568 
15569  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties;
15570  VkResult result = getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
15571  static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) );
15572  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
15573 
15574  return properties;
15575  }
15576 
15577  template <typename X, typename Y, typename... Z>
15579  Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const
15580  {
15583  "Function <vkGetAndroidHardwareBufferPropertiesANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
15584 
15585  StructureChain<X, Y, Z...> structureChain;
15586  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties =
15587  structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>();
15588  VkResult result = getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
15589  static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) );
15590  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
15591 
15592  return structureChain;
15593  }
15594 
15595  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE struct AHardwareBuffer *
15596  Device::getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info ) const
15597  {
15599  "Function <vkGetMemoryAndroidHardwareBufferANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
15600 
15601  struct AHardwareBuffer * buffer;
15602  VkResult result = getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID(
15603  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer );
15604  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" );
15605 
15606  return buffer;
15607  }
15608 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
15609 
15610  //=== VK_EXT_sample_locations ===
15611 
15612  VULKAN_HPP_INLINE void
15613  CommandBuffer::setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
15614  {
15615  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEXT &&
15616  "Function <vkCmdSetSampleLocationsEXT> needs extension <VK_EXT_sample_locations> enabled!" );
15617 
15618  getDispatcher()->vkCmdSetSampleLocationsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15619  reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) );
15620  }
15621 
15623  PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT
15624  {
15626  "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> needs extension <VK_EXT_sample_locations> enabled!" );
15627 
15628  VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties;
15629  getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15630  static_cast<VkSampleCountFlagBits>( samples ),
15631  reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) );
15632 
15633  return multisampleProperties;
15634  }
15635 
15636  //=== VK_KHR_get_memory_requirements2 ===
15637 
15639  Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
15640  {
15642  "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
15643 
15644  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
15645  getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
15646  reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
15647  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
15648 
15649  return memoryRequirements;
15650  }
15651 
15652  template <typename X, typename Y, typename... Z>
15654  Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
15655  {
15657  "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
15658 
15659  StructureChain<X, Y, Z...> structureChain;
15660  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
15661  getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
15662  reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
15663  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
15664 
15665  return structureChain;
15666  }
15667 
15669  Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
15670  {
15672  "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
15673 
15674  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
15675  getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
15676  reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
15677  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
15678 
15679  return memoryRequirements;
15680  }
15681 
15682  template <typename X, typename Y, typename... Z>
15684  Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
15685  {
15687  "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
15688 
15689  StructureChain<X, Y, Z...> structureChain;
15690  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
15691  getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
15692  reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
15693  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
15694 
15695  return structureChain;
15696  }
15697 
15698  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
15699  Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const
15700  {
15702  "Function <vkGetImageSparseMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
15703 
15704  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
15705  uint32_t sparseMemoryRequirementCount;
15706  getDispatcher()->vkGetImageSparseMemoryRequirements2KHR(
15707  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
15708  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
15709  getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
15710  reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
15711  &sparseMemoryRequirementCount,
15712  reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
15713 
15714  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
15715  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
15716  {
15717  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
15718  }
15719  return sparseMemoryRequirements;
15720  }
15721 
15722  //=== VK_KHR_acceleration_structure ===
15723 
15725  Device::createAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo,
15727  {
15728  return VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR( *this, createInfo, allocator );
15729  }
15730 
15731  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR(
15734  {
15736  "Function <vkCmdBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15737  if ( infos.size() != pBuildRangeInfos.size() )
15738  {
15739  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
15740  }
15741 
15742  getDispatcher()->vkCmdBuildAccelerationStructuresKHR(
15743  static_cast<VkCommandBuffer>( m_commandBuffer ),
15744  infos.size(),
15745  reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
15746  reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) );
15747  }
15748 
15749  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR(
15752  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides,
15753  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const
15754  {
15756  "Function <vkCmdBuildAccelerationStructuresIndirectKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15757  if ( infos.size() != indirectDeviceAddresses.size() )
15758  {
15760  "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" );
15761  }
15762  if ( infos.size() != indirectStrides.size() )
15763  {
15764  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" );
15765  }
15766  if ( infos.size() != pMaxPrimitiveCounts.size() )
15767  {
15768  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" );
15769  }
15770 
15771  getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15772  infos.size(),
15773  reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
15774  reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ),
15775  indirectStrides.data(),
15776  pMaxPrimitiveCounts.data() );
15777  }
15778 
15783  {
15785  "Function <vkBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15786  if ( infos.size() != pBuildRangeInfos.size() )
15787  {
15788  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
15789  }
15790 
15791  VkResult result = getDispatcher()->vkBuildAccelerationStructuresKHR(
15792  static_cast<VkDevice>( m_device ),
15793  static_cast<VkDeferredOperationKHR>( deferredOperation ),
15794  infos.size(),
15795  reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
15796  reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) );
15797  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
15798  VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR",
15802 
15803  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
15804  }
15805 
15807  Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
15809  {
15811  "Function <vkCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15812 
15813  VkResult result = getDispatcher()->vkCopyAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
15814  static_cast<VkDeferredOperationKHR>( deferredOperation ),
15815  reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
15816  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
15817  VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR",
15821 
15822  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
15823  }
15824 
15826  Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
15828  {
15830  "Function <vkCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15831 
15832  VkResult result =
15833  getDispatcher()->vkCopyAccelerationStructureToMemoryKHR( static_cast<VkDevice>( m_device ),
15834  static_cast<VkDeferredOperationKHR>( deferredOperation ),
15835  reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
15836  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
15837  VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR",
15841 
15842  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
15843  }
15844 
15846  Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
15848  {
15850  "Function <vkCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15851 
15852  VkResult result =
15853  getDispatcher()->vkCopyMemoryToAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
15854  static_cast<VkDeferredOperationKHR>( deferredOperation ),
15855  reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
15856  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
15857  VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR",
15861 
15862  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
15863  }
15864 
15865  template <typename DataType>
15866  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> Device::writeAccelerationStructuresPropertiesKHR(
15869  size_t dataSize,
15870  size_t stride ) const
15871  {
15873  "Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15874 
15875  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
15876  std::vector<DataType> data( dataSize / sizeof( DataType ) );
15877  VkResult result =
15878  getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast<VkDevice>( m_device ),
15879  accelerationStructures.size(),
15880  reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
15881  static_cast<VkQueryType>( queryType ),
15882  data.size() * sizeof( DataType ),
15883  reinterpret_cast<void *>( data.data() ),
15884  stride );
15885  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
15886 
15887  return data;
15888  }
15889 
15890  template <typename DataType>
15891  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Device::writeAccelerationStructuresPropertyKHR(
15894  size_t stride ) const
15895  {
15897  "Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15898 
15899  DataType data;
15900  VkResult result =
15901  getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast<VkDevice>( m_device ),
15902  accelerationStructures.size(),
15903  reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
15904  static_cast<VkQueryType>( queryType ),
15905  sizeof( DataType ),
15906  reinterpret_cast<void *>( &data ),
15907  stride );
15908  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" );
15909 
15910  return data;
15911  }
15912 
15913  VULKAN_HPP_INLINE void
15914  CommandBuffer::copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
15915  {
15917  "Function <vkCmdCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15918 
15919  getDispatcher()->vkCmdCopyAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15920  reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
15921  }
15922 
15923  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR(
15924  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
15925  {
15927  "Function <vkCmdCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15928 
15929  getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15930  reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
15931  }
15932 
15933  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR(
15934  const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
15935  {
15937  "Function <vkCmdCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15938 
15939  getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15940  reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
15941  }
15942 
15944  Device::getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
15945  {
15947  "Function <vkGetAccelerationStructureDeviceAddressKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15948 
15949  VkDeviceAddress result = getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR(
15950  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) );
15951 
15952  return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result );
15953  }
15954 
15955  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
15959  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
15960  {
15962  "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15963 
15964  getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15965  accelerationStructures.size(),
15966  reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
15967  static_cast<VkQueryType>( queryType ),
15968  static_cast<VkQueryPool>( queryPool ),
15969  firstQuery );
15970  }
15971 
15973  const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT
15974  {
15976  "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15977 
15979  getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR( static_cast<VkDevice>( m_device ),
15980  reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ),
15981  reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
15982 
15983  return compatibility;
15984  }
15985 
15987  Device::getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
15989  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts ) const
15990  {
15992  "Function <vkGetAccelerationStructureBuildSizesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15993  if ( maxPrimitiveCounts.size() != buildInfo.geometryCount )
15994  {
15995  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" );
15996  }
15997 
15999  getDispatcher()->vkGetAccelerationStructureBuildSizesKHR( static_cast<VkDevice>( m_device ),
16000  static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
16001  reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ),
16002  maxPrimitiveCounts.data(),
16003  reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) );
16004 
16005  return sizeInfo;
16006  }
16007 
16008  //=== VK_KHR_sampler_ycbcr_conversion ===
16009 
16010  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion
16011  Device::createSamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,
16013  {
16014  return VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion( *this, createInfo, allocator );
16015  }
16016 
16017  VULKAN_HPP_INLINE void
16018  Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
16019  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT
16020  {
16022  "Function <vkDestroySamplerYcbcrConversionKHR> needs extension <VK_KHR_sampler_ycbcr_conversion> enabled!" );
16023 
16024  getDispatcher()->vkDestroySamplerYcbcrConversionKHR(
16025  static_cast<VkDevice>( m_device ),
16026  static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
16027  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
16028  }
16029 
16030  //=== VK_KHR_bind_memory2 ===
16031 
16032  VULKAN_HPP_INLINE void
16033  Device::bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const
16034  {
16035  VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2KHR && "Function <vkBindBufferMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!" );
16036 
16037  VkResult result = getDispatcher()->vkBindBufferMemory2KHR(
16038  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) );
16039  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" );
16040  }
16041 
16042  VULKAN_HPP_INLINE void
16043  Device::bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const
16044  {
16045  VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2KHR && "Function <vkBindImageMemory2KHR> needs extension <VK_KHR_bind_memory2> enabled!" );
16046 
16047  VkResult result = getDispatcher()->vkBindImageMemory2KHR(
16048  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) );
16049  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" );
16050  }
16051 
16052  //=== VK_EXT_image_drm_format_modifier ===
16053 
16055  {
16057  "Function <vkGetImageDrmFormatModifierPropertiesEXT> needs extension <VK_EXT_image_drm_format_modifier> enabled!" );
16058 
16060  VkResult result = getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT(
16061  static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) );
16062  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" );
16063 
16064  return properties;
16065  }
16066 
16067  //=== VK_EXT_validation_cache ===
16068 
16070  Device::createValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo,
16072  {
16073  return VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT( *this, createInfo, allocator );
16074  }
16075 
16077  {
16078  VULKAN_HPP_ASSERT( getDispatcher()->vkMergeValidationCachesEXT &&
16079  "Function <vkMergeValidationCachesEXT> needs extension <VK_EXT_validation_cache> enabled!" );
16080 
16081  VkResult result = getDispatcher()->vkMergeValidationCachesEXT( static_cast<VkDevice>( m_device ),
16082  static_cast<VkValidationCacheEXT>( m_validationCache ),
16083  srcCaches.size(),
16084  reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) );
16085  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::merge" );
16086  }
16087 
16088  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ValidationCacheEXT::getData() const
16089  {
16090  VULKAN_HPP_ASSERT( getDispatcher()->vkGetValidationCacheDataEXT &&
16091  "Function <vkGetValidationCacheDataEXT> needs extension <VK_EXT_validation_cache> enabled!" );
16092 
16093  std::vector<uint8_t> data;
16094  size_t dataSize;
16095  VkResult result;
16096  do
16097  {
16098  result = getDispatcher()->vkGetValidationCacheDataEXT(
16099  static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( m_validationCache ), &dataSize, nullptr );
16100  if ( ( result == VK_SUCCESS ) && dataSize )
16101  {
16102  data.resize( dataSize );
16103  result = getDispatcher()->vkGetValidationCacheDataEXT(
16104  static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( m_validationCache ), &dataSize, reinterpret_cast<void *>( data.data() ) );
16105  }
16106  } while ( result == VK_INCOMPLETE );
16107  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::getData" );
16108  VULKAN_HPP_ASSERT( dataSize <= data.size() );
16109  if ( dataSize < data.size() )
16110  {
16111  data.resize( dataSize );
16112  }
16113  return data;
16114  }
16115 
16116  //=== VK_NV_shading_rate_image ===
16117 
16118  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView,
16119  VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
16120  {
16121  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadingRateImageNV &&
16122  "Function <vkCmdBindShadingRateImageNV> needs extension <VK_NV_shading_rate_image> enabled!" );
16123 
16124  getDispatcher()->vkCmdBindShadingRateImageNV(
16125  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
16126  }
16127 
16128  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
16129  uint32_t firstViewport,
16130  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
16131  {
16133  "Function <vkCmdSetViewportShadingRatePaletteNV> needs extension <VK_NV_shading_rate_image> enabled!" );
16134 
16135  getDispatcher()->vkCmdSetViewportShadingRatePaletteNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16136  firstViewport,
16137  shadingRatePalettes.size(),
16138  reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) );
16139  }
16140 
16141  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV(
16143  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders ) const VULKAN_HPP_NOEXCEPT
16144  {
16145  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoarseSampleOrderNV &&
16146  "Function <vkCmdSetCoarseSampleOrderNV> needs extension <VK_NV_shading_rate_image> enabled!" );
16147 
16148  getDispatcher()->vkCmdSetCoarseSampleOrderNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16149  static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
16150  customSampleOrders.size(),
16151  reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) );
16152  }
16153 
16154  //=== VK_NV_ray_tracing ===
16155 
16157  Device::createAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo,
16159  {
16160  return VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV( *this, createInfo, allocator );
16161  }
16162 
16163  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV(
16164  const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
16165  {
16167  "Function <vkGetAccelerationStructureMemoryRequirementsNV> needs extension <VK_NV_ray_tracing> enabled!" );
16168 
16170  getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
16171  reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
16172  reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
16173 
16174  return memoryRequirements;
16175  }
16176 
16177  template <typename X, typename Y, typename... Z>
16178  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::getAccelerationStructureMemoryRequirementsNV(
16179  const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
16180  {
16182  "Function <vkGetAccelerationStructureMemoryRequirementsNV> needs extension <VK_NV_ray_tracing> enabled!" );
16183 
16184  StructureChain<X, Y, Z...> structureChain;
16185  VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>();
16186  getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
16187  reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
16188  reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
16189 
16190  return structureChain;
16191  }
16192 
16193  VULKAN_HPP_INLINE void Device::bindAccelerationStructureMemoryNV(
16195  {
16197  "Function <vkBindAccelerationStructureMemoryNV> needs extension <VK_NV_ray_tracing> enabled!" );
16198 
16199  VkResult result = getDispatcher()->vkBindAccelerationStructureMemoryNV(
16200  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) );
16201  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" );
16202  }
16203 
16204  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
16205  VULKAN_HPP_NAMESPACE::Buffer instanceData,
16206  VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
16211  VULKAN_HPP_NAMESPACE::DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT
16212  {
16214  "Function <vkCmdBuildAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" );
16215 
16216  getDispatcher()->vkCmdBuildAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16217  reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ),
16218  static_cast<VkBuffer>( instanceData ),
16219  static_cast<VkDeviceSize>( instanceOffset ),
16220  static_cast<VkBool32>( update ),
16221  static_cast<VkAccelerationStructureNV>( dst ),
16222  static_cast<VkAccelerationStructureNV>( src ),
16223  static_cast<VkBuffer>( scratch ),
16224  static_cast<VkDeviceSize>( scratchOffset ) );
16225  }
16226 
16227  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
16230  {
16232  "Function <vkCmdCopyAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" );
16233 
16234  getDispatcher()->vkCmdCopyAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16235  static_cast<VkAccelerationStructureNV>( dst ),
16236  static_cast<VkAccelerationStructureNV>( src ),
16237  static_cast<VkCopyAccelerationStructureModeKHR>( mode ) );
16238  }
16239 
16240  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer,
16241  VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
16242  VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer,
16243  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
16244  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
16245  VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer,
16246  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
16247  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
16248  VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,
16249  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
16250  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
16251  uint32_t width,
16252  uint32_t height,
16253  uint32_t depth ) const VULKAN_HPP_NOEXCEPT
16254  {
16255  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysNV && "Function <vkCmdTraceRaysNV> needs extension <VK_NV_ray_tracing> enabled!" );
16256 
16257  getDispatcher()->vkCmdTraceRaysNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16258  static_cast<VkBuffer>( raygenShaderBindingTableBuffer ),
16259  static_cast<VkDeviceSize>( raygenShaderBindingOffset ),
16260  static_cast<VkBuffer>( missShaderBindingTableBuffer ),
16261  static_cast<VkDeviceSize>( missShaderBindingOffset ),
16262  static_cast<VkDeviceSize>( missShaderBindingStride ),
16263  static_cast<VkBuffer>( hitShaderBindingTableBuffer ),
16264  static_cast<VkDeviceSize>( hitShaderBindingOffset ),
16265  static_cast<VkDeviceSize>( hitShaderBindingStride ),
16266  static_cast<VkBuffer>( callableShaderBindingTableBuffer ),
16267  static_cast<VkDeviceSize>( callableShaderBindingOffset ),
16268  static_cast<VkDeviceSize>( callableShaderBindingStride ),
16269  width,
16270  height,
16271  depth );
16272  }
16273 
16274  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> Device::createRayTracingPipelinesNV(
16278  {
16279  return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, pipelineCache, createInfos, allocator );
16280  }
16281 
16286  {
16287  return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, pipelineCache, createInfo, allocator );
16288  }
16289 
16290  template <typename DataType>
16291  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
16292  Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
16293  {
16295  "Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!" );
16296 
16297  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
16298  std::vector<DataType> data( dataSize / sizeof( DataType ) );
16299  VkResult result = getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
16300  static_cast<VkPipeline>( m_pipeline ),
16301  firstGroup,
16302  groupCount,
16303  data.size() * sizeof( DataType ),
16304  reinterpret_cast<void *>( data.data() ) );
16305  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesNV" );
16306 
16307  return data;
16308  }
16309 
16310  template <typename DataType>
16311  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const
16312  {
16314  "Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!" );
16315 
16316  DataType data;
16317  VkResult result = getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
16318  static_cast<VkPipeline>( m_pipeline ),
16319  firstGroup,
16320  groupCount,
16321  sizeof( DataType ),
16322  reinterpret_cast<void *>( &data ) );
16323  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleNV" );
16324 
16325  return data;
16326  }
16327 
16328  template <typename DataType>
16329  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> AccelerationStructureNV::getHandle( size_t dataSize ) const
16330  {
16332  "Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!" );
16333 
16334  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
16335  std::vector<DataType> data( dataSize / sizeof( DataType ) );
16336  VkResult result = getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast<VkDevice>( m_device ),
16337  static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
16338  data.size() * sizeof( DataType ),
16339  reinterpret_cast<void *>( data.data() ) );
16340  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" );
16341 
16342  return data;
16343  }
16344 
16345  template <typename DataType>
16346  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType AccelerationStructureNV::getHandle() const
16347  {
16349  "Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!" );
16350 
16351  DataType data;
16352  VkResult result = getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast<VkDevice>( m_device ),
16353  static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
16354  sizeof( DataType ),
16355  reinterpret_cast<void *>( &data ) );
16356  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" );
16357 
16358  return data;
16359  }
16360 
16361  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
16365  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
16366  {
16368  "Function <vkCmdWriteAccelerationStructuresPropertiesNV> needs extension <VK_NV_ray_tracing> enabled!" );
16369 
16370  getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16371  accelerationStructures.size(),
16372  reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ),
16373  static_cast<VkQueryType>( queryType ),
16374  static_cast<VkQueryPool>( queryPool ),
16375  firstQuery );
16376  }
16377 
16378  VULKAN_HPP_INLINE void Pipeline::compileDeferredNV( uint32_t shader ) const
16379  {
16380  VULKAN_HPP_ASSERT( getDispatcher()->vkCompileDeferredNV && "Function <vkCompileDeferredNV> needs extension <VK_NV_ray_tracing> enabled!" );
16381 
16382  VkResult result = getDispatcher()->vkCompileDeferredNV( static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), shader );
16383  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Pipeline::compileDeferredNV" );
16384  }
16385 
16386  //=== VK_KHR_maintenance3 ===
16387 
16389  Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
16390  {
16392  "Function <vkGetDescriptorSetLayoutSupportKHR> needs extension <VK_KHR_maintenance3> enabled!" );
16393 
16395  getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast<VkDevice>( m_device ),
16396  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
16397  reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
16398 
16399  return support;
16400  }
16401 
16402  template <typename X, typename Y, typename... Z>
16404  Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
16405  {
16407  "Function <vkGetDescriptorSetLayoutSupportKHR> needs extension <VK_KHR_maintenance3> enabled!" );
16408 
16409  StructureChain<X, Y, Z...> structureChain;
16410  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
16411  getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast<VkDevice>( m_device ),
16412  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
16413  reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
16414 
16415  return structureChain;
16416  }
16417 
16418  //=== VK_KHR_draw_indirect_count ===
16419 
16420  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
16422  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
16423  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
16424  uint32_t maxDrawCount,
16425  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
16426  {
16427  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountKHR &&
16428  "Function <vkCmdDrawIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" );
16429 
16430  getDispatcher()->vkCmdDrawIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
16431  static_cast<VkBuffer>( buffer ),
16432  static_cast<VkDeviceSize>( offset ),
16433  static_cast<VkBuffer>( countBuffer ),
16434  static_cast<VkDeviceSize>( countBufferOffset ),
16435  maxDrawCount,
16436  stride );
16437  }
16438 
16439  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
16441  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
16442  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
16443  uint32_t maxDrawCount,
16444  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
16445  {
16447  "Function <vkCmdDrawIndexedIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" );
16448 
16449  getDispatcher()->vkCmdDrawIndexedIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
16450  static_cast<VkBuffer>( buffer ),
16451  static_cast<VkDeviceSize>( offset ),
16452  static_cast<VkBuffer>( countBuffer ),
16453  static_cast<VkDeviceSize>( countBufferOffset ),
16454  maxDrawCount,
16455  stride );
16456  }
16457 
16458  //=== VK_EXT_external_memory_host ===
16459 
16461  Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const
16462  {
16464  "Function <vkGetMemoryHostPointerPropertiesEXT> needs extension <VK_EXT_external_memory_host> enabled!" );
16465 
16466  VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
16467  VkResult result =
16468  getDispatcher()->vkGetMemoryHostPointerPropertiesEXT( static_cast<VkDevice>( m_device ),
16469  static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
16470  pHostPointer,
16471  reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) );
16472  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" );
16473 
16474  return memoryHostPointerProperties;
16475  }
16476 
16477  //=== VK_AMD_buffer_marker ===
16478 
16479  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
16480  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
16482  uint32_t marker ) const VULKAN_HPP_NOEXCEPT
16483  {
16484  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarkerAMD && "Function <vkCmdWriteBufferMarkerAMD> needs extension <VK_AMD_buffer_marker> enabled!" );
16485 
16486  getDispatcher()->vkCmdWriteBufferMarkerAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
16487  static_cast<VkPipelineStageFlagBits>( pipelineStage ),
16488  static_cast<VkBuffer>( dstBuffer ),
16489  static_cast<VkDeviceSize>( dstOffset ),
16490  marker );
16491  }
16492 
16493  //=== VK_EXT_calibrated_timestamps ===
16494 
16495  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> PhysicalDevice::getCalibrateableTimeDomainsEXT() const
16496  {
16498  "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
16499 
16500  std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> timeDomains;
16501  uint32_t timeDomainCount;
16502  VkResult result;
16503  do
16504  {
16505  result =
16506  getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr );
16507  if ( ( result == VK_SUCCESS ) && timeDomainCount )
16508  {
16509  timeDomains.resize( timeDomainCount );
16510  result = getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
16511  static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) );
16512  }
16513  } while ( result == VK_INCOMPLETE );
16514  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
16515  VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
16516  if ( timeDomainCount < timeDomains.size() )
16517  {
16518  timeDomains.resize( timeDomainCount );
16519  }
16520  return timeDomains;
16521  }
16522 
16523  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t> Device::getCalibratedTimestampsEXT(
16525  {
16526  VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT &&
16527  "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
16528 
16529  std::pair<std::vector<uint64_t>, uint64_t> data( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
16530  std::vector<uint64_t> & timestamps = data.first;
16531  uint64_t & maxDeviation = data.second;
16532  VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast<VkDevice>( m_device ),
16533  timestampInfos.size(),
16534  reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
16535  timestamps.data(),
16536  &maxDeviation );
16537  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
16538 
16539  return data;
16540  }
16541 
16542  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t>
16543  Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo ) const
16544  {
16545  VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT &&
16546  "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
16547 
16548  std::pair<uint64_t, uint64_t> data;
16549  uint64_t & timestamp = data.first;
16550  uint64_t & maxDeviation = data.second;
16551  VkResult result = getDispatcher()->vkGetCalibratedTimestampsEXT(
16552  static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ), &timestamp, &maxDeviation );
16553  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
16554 
16555  return data;
16556  }
16557 
16558  //=== VK_NV_mesh_shader ===
16559 
16560  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
16561  {
16562  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksNV && "Function <vkCmdDrawMeshTasksNV> needs extension <VK_NV_mesh_shader> enabled!" );
16563 
16564  getDispatcher()->vkCmdDrawMeshTasksNV( static_cast<VkCommandBuffer>( m_commandBuffer ), taskCount, firstTask );
16565  }
16566 
16567  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
16569  uint32_t drawCount,
16570  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
16571  {
16572  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectNV &&
16573  "Function <vkCmdDrawMeshTasksIndirectNV> needs extension <VK_NV_mesh_shader> enabled!" );
16574 
16575  getDispatcher()->vkCmdDrawMeshTasksIndirectNV(
16576  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
16577  }
16578 
16579  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
16581  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
16582  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
16583  uint32_t maxDrawCount,
16584  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
16585  {
16587  "Function <vkCmdDrawMeshTasksIndirectCountNV> needs extension <VK_NV_mesh_shader> enabled!" );
16588 
16589  getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16590  static_cast<VkBuffer>( buffer ),
16591  static_cast<VkDeviceSize>( offset ),
16592  static_cast<VkBuffer>( countBuffer ),
16593  static_cast<VkDeviceSize>( countBufferOffset ),
16594  maxDrawCount,
16595  stride );
16596  }
16597 
16598  //=== VK_NV_scissor_exclusive ===
16599 
16600  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV(
16601  uint32_t firstExclusiveScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT
16602  {
16603  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorNV &&
16604  "Function <vkCmdSetExclusiveScissorNV> needs extension <VK_NV_scissor_exclusive> enabled!" );
16605 
16606  getDispatcher()->vkCmdSetExclusiveScissorNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16607  firstExclusiveScissor,
16608  exclusiveScissors.size(),
16609  reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) );
16610  }
16611 
16612  //=== VK_NV_device_diagnostic_checkpoints ===
16613 
16614  template <typename CheckpointMarkerType>
16615  VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT
16616  {
16617  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCheckpointNV &&
16618  "Function <vkCmdSetCheckpointNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
16619 
16620  getDispatcher()->vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const void *>( &checkpointMarker ) );
16621  }
16622 
16623  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> Queue::getCheckpointDataNV() const
16624  {
16625  VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointDataNV &&
16626  "Function <vkGetQueueCheckpointDataNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
16627 
16628  std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> checkpointData;
16629  uint32_t checkpointDataCount;
16630  getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
16631  checkpointData.resize( checkpointDataCount );
16632  getDispatcher()->vkGetQueueCheckpointDataNV(
16633  static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
16634 
16635  VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
16636  if ( checkpointDataCount < checkpointData.size() )
16637  {
16638  checkpointData.resize( checkpointDataCount );
16639  }
16640  return checkpointData;
16641  }
16642 
16643  //=== VK_KHR_timeline_semaphore ===
16644 
16645  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValueKHR() const
16646  {
16648  "Function <vkGetSemaphoreCounterValueKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
16649 
16650  uint64_t value;
16651  VkResult result = getDispatcher()->vkGetSemaphoreCounterValueKHR( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value );
16652  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" );
16653 
16654  return value;
16655  }
16656 
16658  uint64_t timeout ) const
16659  {
16660  VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphoresKHR && "Function <vkWaitSemaphoresKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
16661 
16662  VkResult result =
16663  getDispatcher()->vkWaitSemaphoresKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout );
16664  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
16665  VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR",
16667 
16668  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
16669  }
16670 
16671  VULKAN_HPP_INLINE void Device::signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const
16672  {
16673  VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphoreKHR && "Function <vkSignalSemaphoreKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
16674 
16675  VkResult result =
16676  getDispatcher()->vkSignalSemaphoreKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) );
16677  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" );
16678  }
16679 
16680  //=== VK_INTEL_performance_query ===
16681 
16682  VULKAN_HPP_INLINE void Device::initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo ) const
16683  {
16685  "Function <vkInitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16686 
16687  VkResult result = getDispatcher()->vkInitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ),
16688  reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) );
16689  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" );
16690  }
16691 
16692  VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT
16693  {
16695  "Function <vkUninitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16696 
16697  getDispatcher()->vkUninitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ) );
16698  }
16699 
16700  VULKAN_HPP_INLINE void CommandBuffer::setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo ) const
16701  {
16703  "Function <vkCmdSetPerformanceMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16704 
16705  VkResult result = getDispatcher()->vkCmdSetPerformanceMarkerINTEL( static_cast<VkCommandBuffer>( m_commandBuffer ),
16706  reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) );
16707  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" );
16708  }
16709 
16710  VULKAN_HPP_INLINE void CommandBuffer::setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo ) const
16711  {
16713  "Function <vkCmdSetPerformanceStreamMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16714 
16715  VkResult result = getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL( static_cast<VkCommandBuffer>( m_commandBuffer ),
16716  reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) );
16717  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" );
16718  }
16719 
16720  VULKAN_HPP_INLINE void CommandBuffer::setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo ) const
16721  {
16723  "Function <vkCmdSetPerformanceOverrideINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16724 
16725  VkResult result = getDispatcher()->vkCmdSetPerformanceOverrideINTEL( static_cast<VkCommandBuffer>( m_commandBuffer ),
16726  reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) );
16727  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" );
16728  }
16729 
16731  Device::acquirePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const
16732  {
16733  return VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL( *this, acquireInfo );
16734  }
16735 
16736  VULKAN_HPP_INLINE void Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const
16737  {
16739  "Function <vkQueueSetPerformanceConfigurationINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16740 
16741  VkResult result = getDispatcher()->vkQueueSetPerformanceConfigurationINTEL( static_cast<VkQueue>( m_queue ),
16742  static_cast<VkPerformanceConfigurationINTEL>( configuration ) );
16743  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" );
16744  }
16745 
16747  Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const
16748  {
16750  "Function <vkGetPerformanceParameterINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16751 
16753  VkResult result = getDispatcher()->vkGetPerformanceParameterINTEL(
16754  static_cast<VkDevice>( m_device ), static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( &value ) );
16755  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" );
16756 
16757  return value;
16758  }
16759 
16760  //=== VK_AMD_display_native_hdr ===
16761 
16762  VULKAN_HPP_INLINE void SwapchainKHR::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
16763  {
16764  VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD && "Function <vkSetLocalDimmingAMD> needs extension <VK_AMD_display_native_hdr> enabled!" );
16765 
16766  getDispatcher()->vkSetLocalDimmingAMD(
16767  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkBool32>( localDimmingEnable ) );
16768  }
16769 
16770 # if defined( VK_USE_PLATFORM_FUCHSIA )
16771  //=== VK_FUCHSIA_imagepipe_surface ===
16772 
16774  Instance::createImagePipeSurfaceFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo,
16776  {
16777  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
16778  }
16779 # endif /*VK_USE_PLATFORM_FUCHSIA*/
16780 
16781 # if defined( VK_USE_PLATFORM_METAL_EXT )
16782  //=== VK_EXT_metal_surface ===
16783 
16785  Instance::createMetalSurfaceEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo,
16787  {
16788  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
16789  }
16790 # endif /*VK_USE_PLATFORM_METAL_EXT*/
16791 
16792  //=== VK_KHR_fragment_shading_rate ===
16793 
16794  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
16795  PhysicalDevice::getFragmentShadingRatesKHR() const
16796  {
16798  "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" );
16799 
16800  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> fragmentShadingRates;
16801  uint32_t fragmentShadingRateCount;
16802  VkResult result;
16803  do
16804  {
16805  result =
16806  getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &fragmentShadingRateCount, nullptr );
16807  if ( ( result == VK_SUCCESS ) && fragmentShadingRateCount )
16808  {
16809  fragmentShadingRates.resize( fragmentShadingRateCount );
16810  result = getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR(
16811  static_cast<VkPhysicalDevice>( m_physicalDevice ),
16812  &fragmentShadingRateCount,
16813  reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) );
16814  }
16815  } while ( result == VK_INCOMPLETE );
16816  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
16817  VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
16818  if ( fragmentShadingRateCount < fragmentShadingRates.size() )
16819  {
16820  fragmentShadingRates.resize( fragmentShadingRateCount );
16821  }
16822  return fragmentShadingRates;
16823  }
16824 
16825  VULKAN_HPP_INLINE void
16826  CommandBuffer::setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize,
16827  const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
16828  {
16830  "Function <vkCmdSetFragmentShadingRateKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" );
16831 
16832  getDispatcher()->vkCmdSetFragmentShadingRateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
16833  reinterpret_cast<const VkExtent2D *>( &fragmentSize ),
16834  reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
16835  }
16836 
16837  //=== VK_EXT_buffer_device_address ===
16838 
16840  Device::getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
16841  {
16842  VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferDeviceAddressEXT &&
16843  "Function <vkGetBufferDeviceAddressEXT> needs extension <VK_EXT_buffer_device_address> enabled!" );
16844 
16845  VkDeviceAddress result =
16846  getDispatcher()->vkGetBufferDeviceAddressEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
16847 
16848  return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result );
16849  }
16850 
16851  //=== VK_EXT_tooling_info ===
16852 
16853  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> PhysicalDevice::getToolPropertiesEXT() const
16854  {
16856  "Function <vkGetPhysicalDeviceToolPropertiesEXT> needs extension <VK_EXT_tooling_info> enabled!" );
16857 
16858  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties;
16859  uint32_t toolCount;
16860  VkResult result;
16861  do
16862  {
16863  result = getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, nullptr );
16864  if ( ( result == VK_SUCCESS ) && toolCount )
16865  {
16866  toolProperties.resize( toolCount );
16867  result = getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT(
16868  static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) );
16869  }
16870  } while ( result == VK_INCOMPLETE );
16871  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
16872  VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
16873  if ( toolCount < toolProperties.size() )
16874  {
16875  toolProperties.resize( toolCount );
16876  }
16877  return toolProperties;
16878  }
16879 
16880  //=== VK_KHR_present_wait ===
16881 
16882  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result SwapchainKHR::waitForPresent( uint64_t presentId, uint64_t timeout ) const
16883  {
16884  VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForPresentKHR && "Function <vkWaitForPresentKHR> needs extension <VK_KHR_present_wait> enabled!" );
16885 
16886  VkResult result =
16887  getDispatcher()->vkWaitForPresentKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), presentId, timeout );
16888  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
16889  VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::waitForPresent",
16891 
16892  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
16893  }
16894 
16895  //=== VK_NV_cooperative_matrix ===
16896 
16897  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
16898  PhysicalDevice::getCooperativeMatrixPropertiesNV() const
16899  {
16901  "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> needs extension <VK_NV_cooperative_matrix> enabled!" );
16902 
16903  std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> properties;
16904  uint32_t propertyCount;
16905  VkResult result;
16906  do
16907  {
16908  result =
16909  getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr );
16910  if ( ( result == VK_SUCCESS ) && propertyCount )
16911  {
16912  properties.resize( propertyCount );
16913  result = getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
16914  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) );
16915  }
16916  } while ( result == VK_INCOMPLETE );
16917  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
16918  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
16919  if ( propertyCount < properties.size() )
16920  {
16921  properties.resize( propertyCount );
16922  }
16923  return properties;
16924  }
16925 
16926  //=== VK_NV_coverage_reduction_mode ===
16927 
16928  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
16929  PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV() const
16930  {
16933  "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> needs extension <VK_NV_coverage_reduction_mode> enabled!" );
16934 
16935  std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> combinations;
16936  uint32_t combinationCount;
16937  VkResult result;
16938  do
16939  {
16940  result = getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
16941  static_cast<VkPhysicalDevice>( m_physicalDevice ), &combinationCount, nullptr );
16942  if ( ( result == VK_SUCCESS ) && combinationCount )
16943  {
16944  combinations.resize( combinationCount );
16945  result = getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
16946  static_cast<VkPhysicalDevice>( m_physicalDevice ),
16947  &combinationCount,
16948  reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) );
16949  }
16950  } while ( result == VK_INCOMPLETE );
16951  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
16952  VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
16953  VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
16954  if ( combinationCount < combinations.size() )
16955  {
16956  combinations.resize( combinationCount );
16957  }
16958  return combinations;
16959  }
16960 
16961 # if defined( VK_USE_PLATFORM_WIN32_KHR )
16962  //=== VK_EXT_full_screen_exclusive ===
16963 
16964  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
16965  PhysicalDevice::getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
16966  {
16968  "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
16969 
16970  std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
16971  uint32_t presentModeCount;
16972  VkResult result;
16973  do
16974  {
16975  result = getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16976  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
16977  &presentModeCount,
16978  nullptr );
16979  if ( ( result == VK_SUCCESS ) && presentModeCount )
16980  {
16981  presentModes.resize( presentModeCount );
16982  result = getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16983  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
16984  &presentModeCount,
16985  reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) );
16986  }
16987  } while ( result == VK_INCOMPLETE );
16988  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
16989  VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
16990  if ( presentModeCount < presentModes.size() )
16991  {
16992  presentModes.resize( presentModeCount );
16993  }
16994  return presentModes;
16995  }
16996 
16997  VULKAN_HPP_INLINE void SwapchainKHR::acquireFullScreenExclusiveModeEXT() const
16998  {
17000  "Function <vkAcquireFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
17001 
17002  VkResult result = getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) );
17003  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" );
17004  }
17005 
17006  VULKAN_HPP_INLINE void SwapchainKHR::releaseFullScreenExclusiveModeEXT() const
17007  {
17009  "Function <vkReleaseFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
17010 
17011  VkResult result = getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) );
17012  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" );
17013  }
17014 
17016  Device::getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
17017  {
17019  "Function <vkGetDeviceGroupSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
17020 
17022  VkResult result = getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT( static_cast<VkDevice>( m_device ),
17023  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
17024  reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) );
17025  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" );
17026 
17027  return modes;
17028  }
17029 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
17030 
17031  //=== VK_EXT_headless_surface ===
17032 
17033  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR
17034  Instance::createHeadlessSurfaceEXT( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo,
17036  {
17037  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
17038  }
17039 
17040  //=== VK_KHR_buffer_device_address ===
17041 
17043  Device::getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
17044  {
17045  VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferDeviceAddressKHR &&
17046  "Function <vkGetBufferDeviceAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
17047 
17048  VkDeviceAddress result =
17049  getDispatcher()->vkGetBufferDeviceAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
17050 
17051  return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result );
17052  }
17053 
17055  Device::getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
17056  {
17058  "Function <vkGetBufferOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
17059 
17060  uint64_t result =
17061  getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
17062 
17063  return result;
17064  }
17065 
17067  Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
17068  {
17070  "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
17071 
17072  uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ),
17073  reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
17074 
17075  return result;
17076  }
17077 
17078  //=== VK_EXT_line_rasterization ===
17079 
17080  VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
17081  {
17082  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT && "Function <vkCmdSetLineStippleEXT> needs extension <VK_EXT_line_rasterization> enabled!" );
17083 
17084  getDispatcher()->vkCmdSetLineStippleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
17085  }
17086 
17087  //=== VK_EXT_host_query_reset ===
17088 
17089  VULKAN_HPP_INLINE void QueryPool::resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
17090  {
17091  VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPoolEXT && "Function <vkResetQueryPoolEXT> needs extension <VK_EXT_host_query_reset> enabled!" );
17092 
17093  getDispatcher()->vkResetQueryPoolEXT( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
17094  }
17095 
17096  //=== VK_EXT_extended_dynamic_state ===
17097 
17098  VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
17099  {
17100  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullModeEXT && "Function <vkCmdSetCullModeEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17101 
17102  getDispatcher()->vkCmdSetCullModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) );
17103  }
17104 
17105  VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
17106  {
17107  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFaceEXT && "Function <vkCmdSetFrontFaceEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17108 
17109  getDispatcher()->vkCmdSetFrontFaceEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) );
17110  }
17111 
17112  VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
17113  {
17114  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopologyEXT &&
17115  "Function <vkCmdSetPrimitiveTopologyEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17116 
17117  getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) );
17118  }
17119 
17120  VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT(
17121  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
17122  {
17123  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCountEXT &&
17124  "Function <vkCmdSetViewportWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17125 
17126  getDispatcher()->vkCmdSetViewportWithCountEXT(
17127  static_cast<VkCommandBuffer>( m_commandBuffer ), viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
17128  }
17129 
17130  VULKAN_HPP_INLINE void
17131  CommandBuffer::setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
17132  {
17133  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCountEXT &&
17134  "Function <vkCmdSetScissorWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17135 
17136  getDispatcher()->vkCmdSetScissorWithCountEXT(
17137  static_cast<VkCommandBuffer>( m_commandBuffer ), scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
17138  }
17139 
17140  VULKAN_HPP_INLINE void
17141  CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding,
17146  {
17147  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2EXT &&
17148  "Function <vkCmdBindVertexBuffers2EXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17149  if ( buffers.size() != offsets.size() )
17150  {
17151  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" );
17152  }
17153  if ( !sizes.empty() && buffers.size() != sizes.size() )
17154  {
17155  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" );
17156  }
17157  if ( !strides.empty() && buffers.size() != strides.size() )
17158  {
17159  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" );
17160  }
17161 
17162  getDispatcher()->vkCmdBindVertexBuffers2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17163  firstBinding,
17164  buffers.size(),
17165  reinterpret_cast<const VkBuffer *>( buffers.data() ),
17166  reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
17167  reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
17168  reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
17169  }
17170 
17171  VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
17172  {
17173  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnableEXT &&
17174  "Function <vkCmdSetDepthTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17175 
17176  getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) );
17177  }
17178 
17179  VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
17180  {
17181  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnableEXT &&
17182  "Function <vkCmdSetDepthWriteEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17183 
17184  getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) );
17185  }
17186 
17187  VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
17188  {
17189  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOpEXT &&
17190  "Function <vkCmdSetDepthCompareOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17191 
17192  getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) );
17193  }
17194 
17195  VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
17196  {
17198  "Function <vkCmdSetDepthBoundsTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17199 
17200  getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) );
17201  }
17202 
17203  VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
17204  {
17205  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnableEXT &&
17206  "Function <vkCmdSetStencilTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17207 
17208  getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) );
17209  }
17210 
17211  VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
17214  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
17215  VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
17216  {
17217  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOpEXT && "Function <vkCmdSetStencilOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17218 
17219  getDispatcher()->vkCmdSetStencilOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17220  static_cast<VkStencilFaceFlags>( faceMask ),
17221  static_cast<VkStencilOp>( failOp ),
17222  static_cast<VkStencilOp>( passOp ),
17223  static_cast<VkStencilOp>( depthFailOp ),
17224  static_cast<VkCompareOp>( compareOp ) );
17225  }
17226 
17227  //=== VK_KHR_deferred_host_operations ===
17228 
17230  Device::createDeferredOperationKHR( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
17231  {
17232  return VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR( *this, allocator );
17233  }
17234 
17235  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT
17236  {
17238  "Function <vkGetDeferredOperationMaxConcurrencyKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
17239 
17240  uint32_t result =
17241  getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) );
17242 
17243  return result;
17244  }
17245 
17246  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result DeferredOperationKHR::getResult() const VULKAN_HPP_NOEXCEPT
17247  {
17249  "Function <vkGetDeferredOperationResultKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
17250 
17251  VkResult result =
17252  getDispatcher()->vkGetDeferredOperationResultKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) );
17253 
17254  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
17255  }
17256 
17258  {
17259  VULKAN_HPP_ASSERT( getDispatcher()->vkDeferredOperationJoinKHR &&
17260  "Function <vkDeferredOperationJoinKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
17261 
17262  VkResult result = getDispatcher()->vkDeferredOperationJoinKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) );
17263  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
17264  VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join",
17266 
17267  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
17268  }
17269 
17270  //=== VK_KHR_pipeline_executable_properties ===
17271 
17272  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
17273  Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo ) const
17274  {
17276  "Function <vkGetPipelineExecutablePropertiesKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" );
17277 
17278  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> properties;
17279  uint32_t executableCount;
17280  VkResult result;
17281  do
17282  {
17283  result = getDispatcher()->vkGetPipelineExecutablePropertiesKHR(
17284  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr );
17285  if ( ( result == VK_SUCCESS ) && executableCount )
17286  {
17287  properties.resize( executableCount );
17288  result = getDispatcher()->vkGetPipelineExecutablePropertiesKHR( static_cast<VkDevice>( m_device ),
17289  reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ),
17290  &executableCount,
17291  reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) );
17292  }
17293  } while ( result == VK_INCOMPLETE );
17294  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" );
17295  VULKAN_HPP_ASSERT( executableCount <= properties.size() );
17296  if ( executableCount < properties.size() )
17297  {
17298  properties.resize( executableCount );
17299  }
17300  return properties;
17301  }
17302 
17303  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>
17304  Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const
17305  {
17307  "Function <vkGetPipelineExecutableStatisticsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" );
17308 
17309  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> statistics;
17310  uint32_t statisticCount;
17311  VkResult result;
17312  do
17313  {
17314  result = getDispatcher()->vkGetPipelineExecutableStatisticsKHR(
17315  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &statisticCount, nullptr );
17316  if ( ( result == VK_SUCCESS ) && statisticCount )
17317  {
17318  statistics.resize( statisticCount );
17319  result = getDispatcher()->vkGetPipelineExecutableStatisticsKHR( static_cast<VkDevice>( m_device ),
17320  reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
17321  &statisticCount,
17322  reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) );
17323  }
17324  } while ( result == VK_INCOMPLETE );
17325  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" );
17326  VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
17327  if ( statisticCount < statistics.size() )
17328  {
17329  statistics.resize( statisticCount );
17330  }
17331  return statistics;
17332  }
17333 
17334  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
17335  Device::getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const
17336  {
17338  "Function <vkGetPipelineExecutableInternalRepresentationsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" );
17339 
17340  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> internalRepresentations;
17341  uint32_t internalRepresentationCount;
17342  VkResult result;
17343  do
17344  {
17345  result = getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR(
17346  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &internalRepresentationCount, nullptr );
17347  if ( ( result == VK_SUCCESS ) && internalRepresentationCount )
17348  {
17349  internalRepresentations.resize( internalRepresentationCount );
17350  result = getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR(
17351  static_cast<VkDevice>( m_device ),
17352  reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
17353  &internalRepresentationCount,
17354  reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) );
17355  }
17356  } while ( result == VK_INCOMPLETE );
17357  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
17358  VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
17359  VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
17360  if ( internalRepresentationCount < internalRepresentations.size() )
17361  {
17362  internalRepresentations.resize( internalRepresentationCount );
17363  }
17364  return internalRepresentations;
17365  }
17366 
17367  //=== VK_NV_device_generated_commands ===
17368 
17370  Device::getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
17371  {
17373  "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17374 
17375  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
17376  getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
17377  reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
17378  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17379 
17380  return memoryRequirements;
17381  }
17382 
17383  template <typename X, typename Y, typename... Z>
17385  Device::getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
17386  {
17388  "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17389 
17390  StructureChain<X, Y, Z...> structureChain;
17391  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
17392  getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
17393  reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
17394  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17395 
17396  return structureChain;
17397  }
17398 
17399  VULKAN_HPP_INLINE void
17400  CommandBuffer::preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
17401  {
17403  "Function <vkCmdPreprocessGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17404 
17405  getDispatcher()->vkCmdPreprocessGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
17406  reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
17407  }
17408 
17409  VULKAN_HPP_INLINE void
17410  CommandBuffer::executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,
17411  const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
17412  {
17414  "Function <vkCmdExecuteGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17415 
17416  getDispatcher()->vkCmdExecuteGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
17417  static_cast<VkBool32>( isPreprocessed ),
17418  reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
17419  }
17420 
17421  VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
17423  uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT
17424  {
17426  "Function <vkCmdBindPipelineShaderGroupNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17427 
17428  getDispatcher()->vkCmdBindPipelineShaderGroupNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
17429  static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
17430  static_cast<VkPipeline>( pipeline ),
17431  groupIndex );
17432  }
17433 
17435  Device::createIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo,
17437  {
17438  return VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV( *this, createInfo, allocator );
17439  }
17440 
17441  //=== VK_EXT_acquire_drm_display ===
17442 
17443  VULKAN_HPP_INLINE void PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const
17444  {
17445  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireDrmDisplayEXT && "Function <vkAcquireDrmDisplayEXT> needs extension <VK_EXT_acquire_drm_display> enabled!" );
17446 
17447  VkResult result =
17448  getDispatcher()->vkAcquireDrmDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), drmFd, static_cast<VkDisplayKHR>( display ) );
17449  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" );
17450  }
17451 
17452  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const
17453  {
17454  return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, drmFd, connectorId );
17455  }
17456 
17457  //=== VK_EXT_private_data ===
17458 
17460  Device::createPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,
17462  {
17463  return VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot( *this, createInfo, allocator );
17464  }
17465 
17466  VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
17467  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_NOEXCEPT
17468  {
17469  VULKAN_HPP_ASSERT( getDispatcher()->vkDestroyPrivateDataSlotEXT &&
17470  "Function <vkDestroyPrivateDataSlotEXT> needs extension <VK_EXT_private_data> enabled!" );
17471 
17472  getDispatcher()->vkDestroyPrivateDataSlotEXT(
17473  static_cast<VkDevice>( m_device ),
17474  static_cast<VkPrivateDataSlot>( privateDataSlot ),
17475  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
17476  }
17477 
17478  VULKAN_HPP_INLINE void Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
17479  uint64_t objectHandle,
17480  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
17481  uint64_t data ) const
17482  {
17483  VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateDataEXT && "Function <vkSetPrivateDataEXT> needs extension <VK_EXT_private_data> enabled!" );
17484 
17485  VkResult result = getDispatcher()->vkSetPrivateDataEXT(
17486  static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data );
17487  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" );
17488  }
17489 
17490  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
17491  uint64_t objectHandle,
17492  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT
17493  {
17494  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateDataEXT && "Function <vkGetPrivateDataEXT> needs extension <VK_EXT_private_data> enabled!" );
17495 
17496  uint64_t data;
17497  getDispatcher()->vkGetPrivateDataEXT(
17498  static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
17499 
17500  return data;
17501  }
17502 
17503 # if defined( VK_ENABLE_BETA_EXTENSIONS )
17504  //=== VK_KHR_video_encode_queue ===
17505 
17506  VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT
17507  {
17508  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEncodeVideoKHR && "Function <vkCmdEncodeVideoKHR> needs extension <VK_KHR_video_encode_queue> enabled!" );
17509 
17510  getDispatcher()->vkCmdEncodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) );
17511  }
17512 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
17513 
17514 # if defined( VK_USE_PLATFORM_METAL_EXT )
17515  //=== VK_EXT_metal_objects ===
17516 
17517  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT
17518  {
17519  VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> needs extension <VK_EXT_metal_objects> enabled!" );
17520 
17521  VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo;
17522  getDispatcher()->vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
17523 
17524  return metalObjectsInfo;
17525  }
17526 
17527  template <typename X, typename Y, typename... Z>
17528  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain<X, Y, Z...> Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT
17529  {
17530  VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> needs extension <VK_EXT_metal_objects> enabled!" );
17531 
17532  StructureChain<X, Y, Z...> structureChain;
17533  VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo = structureChain.template get<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>();
17534  getDispatcher()->vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
17535 
17536  return structureChain;
17537  }
17538 # endif /*VK_USE_PLATFORM_METAL_EXT*/
17539 
17540  //=== VK_KHR_synchronization2 ===
17541 
17542  VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
17543  const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
17544  {
17545  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2KHR && "Function <vkCmdSetEvent2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
17546 
17547  getDispatcher()->vkCmdSetEvent2KHR(
17548  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
17549  }
17550 
17551  VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
17552  VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
17553  {
17554  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2KHR && "Function <vkCmdResetEvent2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
17555 
17556  getDispatcher()->vkCmdResetEvent2KHR(
17557  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) );
17558  }
17559 
17560  VULKAN_HPP_INLINE void
17561  CommandBuffer::waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
17563  {
17564  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2KHR && "Function <vkCmdWaitEvents2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
17565  if ( events.size() != dependencyInfos.size() )
17566  {
17567  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" );
17568  }
17569 
17570  getDispatcher()->vkCmdWaitEvents2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17571  events.size(),
17572  reinterpret_cast<const VkEvent *>( events.data() ),
17573  reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) );
17574  }
17575 
17576  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
17577  {
17578  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2KHR &&
17579  "Function <vkCmdPipelineBarrier2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
17580 
17581  getDispatcher()->vkCmdPipelineBarrier2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17582  reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
17583  }
17584 
17585  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
17587  uint32_t query ) const VULKAN_HPP_NOEXCEPT
17588  {
17589  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2KHR && "Function <vkCmdWriteTimestamp2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
17590 
17591  getDispatcher()->vkCmdWriteTimestamp2KHR(
17592  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query );
17593  }
17594 
17596  VULKAN_HPP_NAMESPACE::Fence fence ) const
17597  {
17598  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2KHR && "Function <vkQueueSubmit2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
17599 
17600  VkResult result = getDispatcher()->vkQueueSubmit2KHR(
17601  static_cast<VkQueue>( m_queue ), submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) );
17602  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" );
17603  }
17604 
17605  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
17606  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
17608  uint32_t marker ) const VULKAN_HPP_NOEXCEPT
17609  {
17610  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarker2AMD &&
17611  "Function <vkCmdWriteBufferMarker2AMD> needs extension <VK_KHR_synchronization2> enabled!" );
17612 
17613  getDispatcher()->vkCmdWriteBufferMarker2AMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
17614  static_cast<VkPipelineStageFlags2>( stage ),
17615  static_cast<VkBuffer>( dstBuffer ),
17616  static_cast<VkDeviceSize>( dstOffset ),
17617  marker );
17618  }
17619 
17620  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> Queue::getCheckpointData2NV() const
17621  {
17622  VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV &&
17623  "Function <vkGetQueueCheckpointData2NV> needs extension <VK_KHR_synchronization2> enabled!" );
17624 
17625  std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> checkpointData;
17626  uint32_t checkpointDataCount;
17627  getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
17628  checkpointData.resize( checkpointDataCount );
17629  getDispatcher()->vkGetQueueCheckpointData2NV(
17630  static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
17631 
17632  VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
17633  if ( checkpointDataCount < checkpointData.size() )
17634  {
17635  checkpointData.resize( checkpointDataCount );
17636  }
17637  return checkpointData;
17638  }
17639 
17640  //=== VK_EXT_descriptor_buffer ===
17641 
17642  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceSize DescriptorSetLayout::getSizeEXT() const VULKAN_HPP_NOEXCEPT
17643  {
17645  "Function <vkGetDescriptorSetLayoutSizeEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17646 
17647  VULKAN_HPP_NAMESPACE::DeviceSize layoutSizeInBytes;
17648  getDispatcher()->vkGetDescriptorSetLayoutSizeEXT( static_cast<VkDevice>( m_device ),
17649  static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ),
17650  reinterpret_cast<VkDeviceSize *>( &layoutSizeInBytes ) );
17651 
17652  return layoutSizeInBytes;
17653  }
17654 
17656  DescriptorSetLayout::getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT
17657  {
17659  "Function <vkGetDescriptorSetLayoutBindingOffsetEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17660 
17662  getDispatcher()->vkGetDescriptorSetLayoutBindingOffsetEXT(
17663  static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ), binding, reinterpret_cast<VkDeviceSize *>( &offset ) );
17664 
17665  return offset;
17666  }
17667 
17668  template <typename DescriptorType>
17670  Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT
17671  {
17672  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17673 
17674  DescriptorType descriptor;
17675  getDispatcher()->vkGetDescriptorEXT( static_cast<VkDevice>( m_device ),
17676  reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ),
17677  sizeof( DescriptorType ),
17678  reinterpret_cast<void *>( &descriptor ) );
17679 
17680  return descriptor;
17681  }
17682 
17683  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT(
17685  {
17687  "Function <vkCmdBindDescriptorBuffersEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17688 
17689  getDispatcher()->vkCmdBindDescriptorBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17690  bindingInfos.size(),
17691  reinterpret_cast<const VkDescriptorBufferBindingInfoEXT *>( bindingInfos.data() ) );
17692  }
17693 
17694  VULKAN_HPP_INLINE void
17695  CommandBuffer::setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
17697  uint32_t firstSet,
17700  {
17702  "Function <vkCmdSetDescriptorBufferOffsetsEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17703  if ( bufferIndices.size() != offsets.size() )
17704  {
17705  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setDescriptorBufferOffsetsEXT: bufferIndices.size() != offsets.size()" );
17706  }
17707 
17708  getDispatcher()->vkCmdSetDescriptorBufferOffsetsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17709  static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
17710  static_cast<VkPipelineLayout>( layout ),
17711  firstSet,
17712  bufferIndices.size(),
17713  bufferIndices.data(),
17714  reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
17715  }
17716 
17717  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
17719  uint32_t set ) const VULKAN_HPP_NOEXCEPT
17720  {
17722  "Function <vkCmdBindDescriptorBufferEmbeddedSamplersEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17723 
17724  getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT(
17725  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set );
17726  }
17727 
17728  template <typename DataType>
17730  Device::getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info ) const
17731  {
17733  "Function <vkGetBufferOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17734 
17735  DataType data;
17736  VkResult result = getDispatcher()->vkGetBufferOpaqueCaptureDescriptorDataEXT(
17737  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT *>( &info ), &data );
17738  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" );
17739 
17740  return data;
17741  }
17742 
17743  template <typename DataType>
17745  Device::getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info ) const
17746  {
17748  "Function <vkGetImageOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17749 
17750  DataType data;
17751  VkResult result = getDispatcher()->vkGetImageOpaqueCaptureDescriptorDataEXT(
17752  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT *>( &info ), &data );
17753  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" );
17754 
17755  return data;
17756  }
17757 
17758  template <typename DataType>
17760  Device::getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info ) const
17761  {
17763  "Function <vkGetImageViewOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17764 
17765  DataType data;
17766  VkResult result = getDispatcher()->vkGetImageViewOpaqueCaptureDescriptorDataEXT(
17767  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT *>( &info ), &data );
17768  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" );
17769 
17770  return data;
17771  }
17772 
17773  template <typename DataType>
17775  Device::getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info ) const
17776  {
17778  "Function <vkGetSamplerOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17779 
17780  DataType data;
17781  VkResult result = getDispatcher()->vkGetSamplerOpaqueCaptureDescriptorDataEXT(
17782  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT *>( &info ), &data );
17783  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" );
17784 
17785  return data;
17786  }
17787 
17788  template <typename DataType>
17789  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT(
17791  {
17793  "Function <vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17794 
17795  DataType data;
17796  VkResult result = getDispatcher()->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
17797  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT *>( &info ), &data );
17798  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
17799  VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" );
17800 
17801  return data;
17802  }
17803 
17804  //=== VK_NV_fragment_shading_rate_enums ===
17805 
17806  VULKAN_HPP_INLINE void
17807  CommandBuffer::setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate,
17808  const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
17809  {
17811  "Function <vkCmdSetFragmentShadingRateEnumNV> needs extension <VK_NV_fragment_shading_rate_enums> enabled!" );
17812 
17813  getDispatcher()->vkCmdSetFragmentShadingRateEnumNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
17814  static_cast<VkFragmentShadingRateNV>( shadingRate ),
17815  reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
17816  }
17817 
17818  //=== VK_EXT_mesh_shader ===
17819 
17820  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
17821  {
17822  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksEXT && "Function <vkCmdDrawMeshTasksEXT> needs extension <VK_EXT_mesh_shader> enabled!" );
17823 
17824  getDispatcher()->vkCmdDrawMeshTasksEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
17825  }
17826 
17827  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
17829  uint32_t drawCount,
17830  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
17831  {
17833  "Function <vkCmdDrawMeshTasksIndirectEXT> needs extension <VK_EXT_mesh_shader> enabled!" );
17834 
17835  getDispatcher()->vkCmdDrawMeshTasksIndirectEXT(
17836  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
17837  }
17838 
17839  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
17841  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
17842  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
17843  uint32_t maxDrawCount,
17844  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
17845  {
17847  "Function <vkCmdDrawMeshTasksIndirectCountEXT> needs extension <VK_EXT_mesh_shader> enabled!" );
17848 
17849  getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17850  static_cast<VkBuffer>( buffer ),
17851  static_cast<VkDeviceSize>( offset ),
17852  static_cast<VkBuffer>( countBuffer ),
17853  static_cast<VkDeviceSize>( countBufferOffset ),
17854  maxDrawCount,
17855  stride );
17856  }
17857 
17858  //=== VK_KHR_copy_commands2 ===
17859 
17860  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT
17861  {
17862  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2KHR && "Function <vkCmdCopyBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
17863 
17864  getDispatcher()->vkCmdCopyBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( &copyBufferInfo ) );
17865  }
17866 
17867  VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT
17868  {
17869  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2KHR && "Function <vkCmdCopyImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
17870 
17871  getDispatcher()->vkCmdCopyImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( &copyImageInfo ) );
17872  }
17873 
17874  VULKAN_HPP_INLINE void
17875  CommandBuffer::copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
17876  {
17877  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2KHR &&
17878  "Function <vkCmdCopyBufferToImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
17879 
17880  getDispatcher()->vkCmdCopyBufferToImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17881  reinterpret_cast<const VkCopyBufferToImageInfo2 *>( &copyBufferToImageInfo ) );
17882  }
17883 
17884  VULKAN_HPP_INLINE void
17885  CommandBuffer::copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
17886  {
17887  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2KHR &&
17888  "Function <vkCmdCopyImageToBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
17889 
17890  getDispatcher()->vkCmdCopyImageToBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17891  reinterpret_cast<const VkCopyImageToBufferInfo2 *>( &copyImageToBufferInfo ) );
17892  }
17893 
17894  VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT
17895  {
17896  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2KHR && "Function <vkCmdBlitImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
17897 
17898  getDispatcher()->vkCmdBlitImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
17899  }
17900 
17901  VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT
17902  {
17903  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2KHR && "Function <vkCmdResolveImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
17904 
17905  getDispatcher()->vkCmdResolveImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17906  reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
17907  }
17908 
17909  //=== VK_EXT_image_compression_control ===
17910 
17912  Image::getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource ) const VULKAN_HPP_NOEXCEPT
17913  {
17915  "Function <vkGetImageSubresourceLayout2EXT> needs extension <VK_EXT_image_compression_control> enabled!" );
17916 
17918  getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast<VkDevice>( m_device ),
17919  static_cast<VkImage>( m_image ),
17920  reinterpret_cast<const VkImageSubresource2EXT *>( &subresource ),
17921  reinterpret_cast<VkSubresourceLayout2EXT *>( &layout ) );
17922 
17923  return layout;
17924  }
17925 
17926  template <typename X, typename Y, typename... Z>
17928  Image::getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2EXT & subresource ) const VULKAN_HPP_NOEXCEPT
17929  {
17931  "Function <vkGetImageSubresourceLayout2EXT> needs extension <VK_EXT_image_compression_control> enabled!" );
17932 
17933  StructureChain<X, Y, Z...> structureChain;
17934  VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT>();
17935  getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast<VkDevice>( m_device ),
17936  static_cast<VkImage>( m_image ),
17937  reinterpret_cast<const VkImageSubresource2EXT *>( &subresource ),
17938  reinterpret_cast<VkSubresourceLayout2EXT *>( &layout ) );
17939 
17940  return structureChain;
17941  }
17942 
17943  //=== VK_EXT_device_fault ===
17944 
17946  VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>
17947  Device::getFaultInfoEXT() const
17948  {
17949  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultInfoEXT && "Function <vkGetDeviceFaultInfoEXT> needs extension <VK_EXT_device_fault> enabled!" );
17950 
17951  std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> data;
17952  VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT & faultCounts = data.first;
17953  VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT & faultInfo = data.second;
17954  VkResult result = getDispatcher()->vkGetDeviceFaultInfoEXT(
17955  static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceFaultCountsEXT *>( &faultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( &faultInfo ) );
17956  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
17957  VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultInfoEXT",
17959 
17960  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data );
17961  }
17962 
17963 # if defined( VK_USE_PLATFORM_WIN32_KHR )
17964  //=== VK_NV_acquire_winrt_display ===
17965 
17966  VULKAN_HPP_INLINE void DisplayKHR::acquireWinrtNV() const
17967  {
17968  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireWinrtDisplayNV &&
17969  "Function <vkAcquireWinrtDisplayNV> needs extension <VK_NV_acquire_winrt_display> enabled!" );
17970 
17971  VkResult result = getDispatcher()->vkAcquireWinrtDisplayNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) );
17972  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" );
17973  }
17974 
17975  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::DisplayKHR PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId ) const
17976  {
17977  return VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, deviceRelativeId );
17978  }
17979 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
17980 
17981 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
17982  //=== VK_EXT_directfb_surface ===
17983 
17984  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR
17985  Instance::createDirectFBSurfaceEXT( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo,
17987  {
17988  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
17989  }
17990 
17992  PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT
17993  {
17995  "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> needs extension <VK_EXT_directfb_surface> enabled!" );
17996 
17997  VkBool32 result =
17998  getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dfb );
17999 
18000  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
18001  }
18002 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
18003 
18004  //=== VK_KHR_ray_tracing_pipeline ===
18005 
18006  VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
18007  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
18008  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
18009  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
18010  uint32_t width,
18011  uint32_t height,
18012  uint32_t depth ) const VULKAN_HPP_NOEXCEPT
18013  {
18014  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysKHR && "Function <vkCmdTraceRaysKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18015 
18016  getDispatcher()->vkCmdTraceRaysKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18017  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
18018  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
18019  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
18020  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
18021  width,
18022  height,
18023  depth );
18024  }
18025 
18026  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> Device::createRayTracingPipelinesKHR(
18031  {
18032  return VULKAN_HPP_RAII_NAMESPACE::Pipelines( *this, deferredOperation, pipelineCache, createInfos, allocator );
18033  }
18034 
18040  {
18041  return VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, deferredOperation, pipelineCache, createInfo, allocator );
18042  }
18043 
18044  template <typename DataType>
18045  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
18046  Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
18047  {
18049  "Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18050 
18051  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18052  std::vector<DataType> data( dataSize / sizeof( DataType ) );
18053  VkResult result = getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18054  static_cast<VkPipeline>( m_pipeline ),
18055  firstGroup,
18056  groupCount,
18057  data.size() * sizeof( DataType ),
18058  reinterpret_cast<void *>( data.data() ) );
18059  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesKHR" );
18060 
18061  return data;
18062  }
18063 
18064  template <typename DataType>
18065  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const
18066  {
18068  "Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18069 
18070  DataType data;
18071  VkResult result = getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18072  static_cast<VkPipeline>( m_pipeline ),
18073  firstGroup,
18074  groupCount,
18075  sizeof( DataType ),
18076  reinterpret_cast<void *>( &data ) );
18077  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleKHR" );
18078 
18079  return data;
18080  }
18081 
18082  template <typename DataType>
18083  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
18084  Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
18085  {
18087  "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18088 
18089  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18090  std::vector<DataType> data( dataSize / sizeof( DataType ) );
18091  VkResult result = getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18092  static_cast<VkPipeline>( m_pipeline ),
18093  firstGroup,
18094  groupCount,
18095  data.size() * sizeof( DataType ),
18096  reinterpret_cast<void *>( data.data() ) );
18097  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
18098  VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR" );
18099 
18100  return data;
18101  }
18102 
18103  template <typename DataType>
18104  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const
18105  {
18107  "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18108 
18109  DataType data;
18110  VkResult result = getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18111  static_cast<VkPipeline>( m_pipeline ),
18112  firstGroup,
18113  groupCount,
18114  sizeof( DataType ),
18115  reinterpret_cast<void *>( &data ) );
18116  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
18117  VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR" );
18118 
18119  return data;
18120  }
18121 
18122  VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
18123  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
18124  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
18125  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
18126  VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
18127  {
18128  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirectKHR &&
18129  "Function <vkCmdTraceRaysIndirectKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18130 
18131  getDispatcher()->vkCmdTraceRaysIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18132  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
18133  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
18134  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
18135  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
18136  static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
18137  }
18138 
18140  Pipeline::getRayTracingShaderGroupStackSizeKHR( uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
18141  {
18143  "Function <vkGetRayTracingShaderGroupStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18144 
18145  VkDeviceSize result = getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR(
18146  static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), group, static_cast<VkShaderGroupShaderKHR>( groupShader ) );
18147 
18148  return static_cast<VULKAN_HPP_NAMESPACE::DeviceSize>( result );
18149  }
18150 
18151  VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
18152  {
18154  "Function <vkCmdSetRayTracingPipelineStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18155 
18156  getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), pipelineStackSize );
18157  }
18158 
18159  //=== VK_EXT_vertex_input_dynamic_state ===
18160 
18161  VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT(
18164  VULKAN_HPP_NOEXCEPT
18165  {
18166  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetVertexInputEXT &&
18167  "Function <vkCmdSetVertexInputEXT> needs extension <VK_EXT_vertex_input_dynamic_state> enabled!" );
18168 
18169  getDispatcher()->vkCmdSetVertexInputEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18170  vertexBindingDescriptions.size(),
18171  reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ),
18172  vertexAttributeDescriptions.size(),
18173  reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) );
18174  }
18175 
18176 # if defined( VK_USE_PLATFORM_FUCHSIA )
18177  //=== VK_FUCHSIA_external_memory ===
18178 
18180  Device::getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const
18181  {
18183  "Function <vkGetMemoryZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" );
18184 
18185  zx_handle_t zirconHandle;
18186  VkResult result = getDispatcher()->vkGetMemoryZirconHandleFUCHSIA(
18187  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle );
18188  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" );
18189 
18190  return zirconHandle;
18191  }
18192 
18193  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA
18194  Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const
18195  {
18197  "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" );
18198 
18199  VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties;
18200  VkResult result =
18201  getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA( static_cast<VkDevice>( m_device ),
18202  static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
18203  zirconHandle,
18204  reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) );
18205  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" );
18206 
18207  return memoryZirconHandleProperties;
18208  }
18209 # endif /*VK_USE_PLATFORM_FUCHSIA*/
18210 
18211 # if defined( VK_USE_PLATFORM_FUCHSIA )
18212  //=== VK_FUCHSIA_external_semaphore ===
18213 
18214  VULKAN_HPP_INLINE void
18215  Device::importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const
18216  {
18218  "Function <vkImportSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" );
18219 
18220  VkResult result = getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA(
18221  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) );
18222  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" );
18223  }
18224 
18226  Device::getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const
18227  {
18229  "Function <vkGetSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" );
18230 
18231  zx_handle_t zirconHandle;
18232  VkResult result = getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA(
18233  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle );
18234  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" );
18235 
18236  return zirconHandle;
18237  }
18238 # endif /*VK_USE_PLATFORM_FUCHSIA*/
18239 
18240 # if defined( VK_USE_PLATFORM_FUCHSIA )
18241  //=== VK_FUCHSIA_buffer_collection ===
18242 
18243  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA
18244  Device::createBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo,
18246  {
18247  return VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA( *this, createInfo, allocator );
18248  }
18249 
18250  VULKAN_HPP_INLINE void BufferCollectionFUCHSIA::setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const
18251  {
18253  "Function <vkSetBufferCollectionImageConstraintsFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!" );
18254 
18255  VkResult result =
18256  getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast<VkDevice>( m_device ),
18257  static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
18258  reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( &imageConstraintsInfo ) );
18259  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setImageConstraints" );
18260  }
18261 
18262  VULKAN_HPP_INLINE void
18263  BufferCollectionFUCHSIA::setBufferConstraints( const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const
18264  {
18266  "Function <vkSetBufferCollectionBufferConstraintsFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!" );
18267 
18268  VkResult result =
18269  getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast<VkDevice>( m_device ),
18270  static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
18271  reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( &bufferConstraintsInfo ) );
18272  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setBufferConstraints" );
18273  }
18274 
18275  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA BufferCollectionFUCHSIA::getProperties() const
18276  {
18278  "Function <vkGetBufferCollectionPropertiesFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!" );
18279 
18280  VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties;
18281  VkResult result = getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA( static_cast<VkDevice>( m_device ),
18282  static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
18283  reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( &properties ) );
18284  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties" );
18285 
18286  return properties;
18287  }
18288 # endif /*VK_USE_PLATFORM_FUCHSIA*/
18289 
18290  //=== VK_HUAWEI_subpass_shading ===
18291 
18292  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D>
18293  RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const
18294  {
18296  "Function <vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> needs extension <VK_HUAWEI_subpass_shading> enabled!" );
18297 
18298  VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize;
18299  VkResult result = getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
18300  static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<VkExtent2D *>( &maxWorkgroupSize ) );
18301  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
18302  VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI",
18304 
18305  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), maxWorkgroupSize );
18306  }
18307 
18308  VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT
18309  {
18310  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSubpassShadingHUAWEI &&
18311  "Function <vkCmdSubpassShadingHUAWEI> needs extension <VK_HUAWEI_subpass_shading> enabled!" );
18312 
18313  getDispatcher()->vkCmdSubpassShadingHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ) );
18314  }
18315 
18316  //=== VK_HUAWEI_invocation_mask ===
18317 
18318  VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView,
18319  VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
18320  {
18322  "Function <vkCmdBindInvocationMaskHUAWEI> needs extension <VK_HUAWEI_invocation_mask> enabled!" );
18323 
18324  getDispatcher()->vkCmdBindInvocationMaskHUAWEI(
18325  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
18326  }
18327 
18328  //=== VK_NV_external_memory_rdma ===
18329 
18331  Device::getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const
18332  {
18333  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryRemoteAddressNV &&
18334  "Function <vkGetMemoryRemoteAddressNV> needs extension <VK_NV_external_memory_rdma> enabled!" );
18335 
18337  VkResult result = getDispatcher()->vkGetMemoryRemoteAddressNV( static_cast<VkDevice>( m_device ),
18338  reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ),
18339  reinterpret_cast<VkRemoteAddressNV *>( &address ) );
18340  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" );
18341 
18342  return address;
18343  }
18344 
18345  //=== VK_EXT_pipeline_properties ===
18346 
18348  Device::getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo ) const
18349  {
18350  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelinePropertiesEXT &&
18351  "Function <vkGetPipelinePropertiesEXT> needs extension <VK_EXT_pipeline_properties> enabled!" );
18352 
18353  VULKAN_HPP_NAMESPACE::BaseOutStructure pipelineProperties;
18354  VkResult result = getDispatcher()->vkGetPipelinePropertiesEXT( static_cast<VkDevice>( m_device ),
18355  reinterpret_cast<const VkPipelineInfoEXT *>( &pipelineInfo ),
18356  reinterpret_cast<VkBaseOutStructure *>( &pipelineProperties ) );
18357  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" );
18358 
18359  return pipelineProperties;
18360  }
18361 
18362  //=== VK_EXT_extended_dynamic_state2 ===
18363 
18364  VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
18365  {
18367  "Function <vkCmdSetPatchControlPointsEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
18368 
18369  getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), patchControlPoints );
18370  }
18371 
18372  VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
18373  {
18375  "Function <vkCmdSetRasterizerDiscardEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
18376 
18377  getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) );
18378  }
18379 
18380  VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
18381  {
18382  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnableEXT &&
18383  "Function <vkCmdSetDepthBiasEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
18384 
18385  getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) );
18386  }
18387 
18388  VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
18389  {
18390  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT && "Function <vkCmdSetLogicOpEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
18391 
18392  getDispatcher()->vkCmdSetLogicOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkLogicOp>( logicOp ) );
18393  }
18394 
18395  VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
18396  {
18398  "Function <vkCmdSetPrimitiveRestartEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
18399 
18400  getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) );
18401  }
18402 
18403 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
18404  //=== VK_QNX_screen_surface ===
18405 
18407  Instance::createScreenSurfaceQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo,
18409  {
18410  return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, createInfo, allocator );
18411  }
18412 
18414  PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT
18415  {
18417  "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> needs extension <VK_QNX_screen_surface> enabled!" );
18418 
18419  VkBool32 result =
18420  getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &window );
18421 
18422  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
18423  }
18424 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
18425 
18426  //=== VK_EXT_color_write_enable ===
18427 
18428  VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT(
18429  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT
18430  {
18431  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteEnableEXT &&
18432  "Function <vkCmdSetColorWriteEnableEXT> needs extension <VK_EXT_color_write_enable> enabled!" );
18433 
18434  getDispatcher()->vkCmdSetColorWriteEnableEXT(
18435  static_cast<VkCommandBuffer>( m_commandBuffer ), colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) );
18436  }
18437 
18438  //=== VK_KHR_ray_tracing_maintenance1 ===
18439 
18440  VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
18441  {
18442  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirect2KHR &&
18443  "Function <vkCmdTraceRaysIndirect2KHR> needs extension <VK_KHR_ray_tracing_maintenance1> enabled!" );
18444 
18445  getDispatcher()->vkCmdTraceRaysIndirect2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
18446  }
18447 
18448  //=== VK_EXT_multi_draw ===
18449 
18450  VULKAN_HPP_INLINE void
18452  uint32_t instanceCount,
18453  uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
18454  {
18455  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiEXT && "Function <vkCmdDrawMultiEXT> needs extension <VK_EXT_multi_draw> enabled!" );
18456 
18457  getDispatcher()->vkCmdDrawMultiEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18458  vertexInfo.size(),
18459  reinterpret_cast<const VkMultiDrawInfoEXT *>( vertexInfo.data() ),
18460  instanceCount,
18461  firstInstance,
18462  vertexInfo.stride() );
18463  }
18464 
18465  VULKAN_HPP_INLINE void
18467  uint32_t instanceCount,
18468  uint32_t firstInstance,
18469  Optional<const int32_t> vertexOffset ) const VULKAN_HPP_NOEXCEPT
18470  {
18471  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiIndexedEXT && "Function <vkCmdDrawMultiIndexedEXT> needs extension <VK_EXT_multi_draw> enabled!" );
18472 
18473  getDispatcher()->vkCmdDrawMultiIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18474  indexInfo.size(),
18475  reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( indexInfo.data() ),
18476  instanceCount,
18477  firstInstance,
18478  indexInfo.stride(),
18479  static_cast<const int32_t *>( vertexOffset ) );
18480  }
18481 
18482  //=== VK_EXT_opacity_micromap ===
18483 
18485  Device::createMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo,
18487  {
18488  return VULKAN_HPP_RAII_NAMESPACE::MicromapEXT( *this, createInfo, allocator );
18489  }
18490 
18491  VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT(
18493  {
18494  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildMicromapsEXT && "Function <vkCmdBuildMicromapsEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18495 
18496  getDispatcher()->vkCmdBuildMicromapsEXT(
18497  static_cast<VkCommandBuffer>( m_commandBuffer ), infos.size(), reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) );
18498  }
18499 
18501  Device::buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
18503  {
18504  VULKAN_HPP_ASSERT( getDispatcher()->vkBuildMicromapsEXT && "Function <vkBuildMicromapsEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18505 
18506  VkResult result = getDispatcher()->vkBuildMicromapsEXT( static_cast<VkDevice>( m_device ),
18507  static_cast<VkDeferredOperationKHR>( deferredOperation ),
18508  infos.size(),
18509  reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) );
18510  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
18511  VULKAN_HPP_NAMESPACE_STRING "::Device::buildMicromapsEXT",
18515 
18516  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
18517  }
18518 
18520  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const
18521  {
18522  VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapEXT && "Function <vkCopyMicromapEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18523 
18524  VkResult result = getDispatcher()->vkCopyMicromapEXT(
18525  static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( deferredOperation ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) );
18526  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
18527  VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapEXT",
18531 
18532  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
18533  }
18534 
18536  Device::copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
18538  {
18539  VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapToMemoryEXT &&
18540  "Function <vkCopyMicromapToMemoryEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18541 
18542  VkResult result = getDispatcher()->vkCopyMicromapToMemoryEXT( static_cast<VkDevice>( m_device ),
18543  static_cast<VkDeferredOperationKHR>( deferredOperation ),
18544  reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) );
18545  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
18546  VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapToMemoryEXT",
18550 
18551  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
18552  }
18553 
18555  Device::copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
18557  {
18558  VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToMicromapEXT &&
18559  "Function <vkCopyMemoryToMicromapEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18560 
18561  VkResult result = getDispatcher()->vkCopyMemoryToMicromapEXT( static_cast<VkDevice>( m_device ),
18562  static_cast<VkDeferredOperationKHR>( deferredOperation ),
18563  reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) );
18564  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
18565  VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToMicromapEXT",
18569 
18570  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
18571  }
18572 
18573  template <typename DataType>
18574  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
18575  Device::writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
18577  size_t dataSize,
18578  size_t stride ) const
18579  {
18581  "Function <vkWriteMicromapsPropertiesEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18582 
18583  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18584  std::vector<DataType> data( dataSize / sizeof( DataType ) );
18585  VkResult result = getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast<VkDevice>( m_device ),
18586  micromaps.size(),
18587  reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ),
18588  static_cast<VkQueryType>( queryType ),
18589  data.size() * sizeof( DataType ),
18590  reinterpret_cast<void *>( data.data() ),
18591  stride );
18592  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" );
18593 
18594  return data;
18595  }
18596 
18597  template <typename DataType>
18599  Device::writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
18601  size_t stride ) const
18602  {
18604  "Function <vkWriteMicromapsPropertiesEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18605 
18606  DataType data;
18607  VkResult result = getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast<VkDevice>( m_device ),
18608  micromaps.size(),
18609  reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ),
18610  static_cast<VkQueryType>( queryType ),
18611  sizeof( DataType ),
18612  reinterpret_cast<void *>( &data ),
18613  stride );
18614  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" );
18615 
18616  return data;
18617  }
18618 
18619  VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT
18620  {
18621  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapEXT && "Function <vkCmdCopyMicromapEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18622 
18623  getDispatcher()->vkCmdCopyMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) );
18624  }
18625 
18626  VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT
18627  {
18628  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapToMemoryEXT &&
18629  "Function <vkCmdCopyMicromapToMemoryEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18630 
18631  getDispatcher()->vkCmdCopyMicromapToMemoryEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18632  reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) );
18633  }
18634 
18635  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT
18636  {
18637  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToMicromapEXT &&
18638  "Function <vkCmdCopyMemoryToMicromapEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18639 
18640  getDispatcher()->vkCmdCopyMemoryToMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18641  reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) );
18642  }
18643 
18644  VULKAN_HPP_INLINE void
18645  CommandBuffer::writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
18648  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
18649  {
18651  "Function <vkCmdWriteMicromapsPropertiesEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18652 
18653  getDispatcher()->vkCmdWriteMicromapsPropertiesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18654  micromaps.size(),
18655  reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ),
18656  static_cast<VkQueryType>( queryType ),
18657  static_cast<VkQueryPool>( queryPool ),
18658  firstQuery );
18659  }
18660 
18662  Device::getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT
18663  {
18665  "Function <vkGetDeviceMicromapCompatibilityEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18666 
18668  getDispatcher()->vkGetDeviceMicromapCompatibilityEXT( static_cast<VkDevice>( m_device ),
18669  reinterpret_cast<const VkMicromapVersionInfoEXT *>( &versionInfo ),
18670  reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
18671 
18672  return compatibility;
18673  }
18674 
18676  Device::getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
18677  const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo ) const VULKAN_HPP_NOEXCEPT
18678  {
18679  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMicromapBuildSizesEXT &&
18680  "Function <vkGetMicromapBuildSizesEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18681 
18683  getDispatcher()->vkGetMicromapBuildSizesEXT( static_cast<VkDevice>( m_device ),
18684  static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
18685  reinterpret_cast<const VkMicromapBuildInfoEXT *>( &buildInfo ),
18686  reinterpret_cast<VkMicromapBuildSizesInfoEXT *>( &sizeInfo ) );
18687 
18688  return sizeInfo;
18689  }
18690 
18691  //=== VK_EXT_pageable_device_local_memory ===
18692 
18693  VULKAN_HPP_INLINE void DeviceMemory::setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT
18694  {
18695  VULKAN_HPP_ASSERT( getDispatcher()->vkSetDeviceMemoryPriorityEXT &&
18696  "Function <vkSetDeviceMemoryPriorityEXT> needs extension <VK_EXT_pageable_device_local_memory> enabled!" );
18697 
18698  getDispatcher()->vkSetDeviceMemoryPriorityEXT( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), priority );
18699  }
18700 
18701  //=== VK_KHR_maintenance4 ===
18702 
18704  Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
18705  {
18707  "Function <vkGetDeviceBufferMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
18708 
18709  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
18710  getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
18711  reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
18712  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
18713 
18714  return memoryRequirements;
18715  }
18716 
18717  template <typename X, typename Y, typename... Z>
18719  Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
18720  {
18722  "Function <vkGetDeviceBufferMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
18723 
18724  StructureChain<X, Y, Z...> structureChain;
18725  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
18726  getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
18727  reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
18728  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
18729 
18730  return structureChain;
18731  }
18732 
18734  Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
18735  {
18737  "Function <vkGetDeviceImageMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
18738 
18739  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
18740  getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
18741  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
18742  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
18743 
18744  return memoryRequirements;
18745  }
18746 
18747  template <typename X, typename Y, typename... Z>
18749  Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
18750  {
18752  "Function <vkGetDeviceImageMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
18753 
18754  StructureChain<X, Y, Z...> structureChain;
18755  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
18756  getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
18757  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
18758  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
18759 
18760  return structureChain;
18761  }
18762 
18763  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
18764  Device::getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const
18765  {
18767  "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
18768 
18769  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
18770  uint32_t sparseMemoryRequirementCount;
18771  getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR(
18772  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
18773  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
18774  getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
18775  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
18776  &sparseMemoryRequirementCount,
18777  reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
18778 
18779  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
18780  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
18781  {
18782  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
18783  }
18784  return sparseMemoryRequirements;
18785  }
18786 
18787  //=== VK_VALVE_descriptor_set_host_mapping ===
18788 
18790  const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference ) const VULKAN_HPP_NOEXCEPT
18791  {
18793  "Function <vkGetDescriptorSetLayoutHostMappingInfoVALVE> needs extension <VK_VALVE_descriptor_set_host_mapping> enabled!" );
18794 
18796  getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE( static_cast<VkDevice>( m_device ),
18797  reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>( &bindingReference ),
18798  reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( &hostMapping ) );
18799 
18800  return hostMapping;
18801  }
18802 
18803  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * DescriptorSet::getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT
18804  {
18806  "Function <vkGetDescriptorSetHostMappingVALVE> needs extension <VK_VALVE_descriptor_set_host_mapping> enabled!" );
18807 
18808  void * pData;
18809  getDispatcher()->vkGetDescriptorSetHostMappingVALVE( static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSet>( m_descriptorSet ), &pData );
18810 
18811  return pData;
18812  }
18813 
18814  //=== VK_NV_copy_memory_indirect ===
18815 
18816  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,
18817  uint32_t copyCount,
18818  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
18819  {
18820  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryIndirectNV &&
18821  "Function <vkCmdCopyMemoryIndirectNV> needs extension <VK_NV_copy_memory_indirect> enabled!" );
18822 
18823  getDispatcher()->vkCmdCopyMemoryIndirectNV(
18824  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( copyBufferAddress ), copyCount, stride );
18825  }
18826 
18827  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV(
18828  VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,
18829  uint32_t stride,
18830  VULKAN_HPP_NAMESPACE::Image dstImage,
18831  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
18832  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources ) const VULKAN_HPP_NOEXCEPT
18833  {
18835  "Function <vkCmdCopyMemoryToImageIndirectNV> needs extension <VK_NV_copy_memory_indirect> enabled!" );
18836 
18837  getDispatcher()->vkCmdCopyMemoryToImageIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18838  static_cast<VkDeviceAddress>( copyBufferAddress ),
18839  imageSubresources.size(),
18840  stride,
18841  static_cast<VkImage>( dstImage ),
18842  static_cast<VkImageLayout>( dstImageLayout ),
18843  reinterpret_cast<const VkImageSubresourceLayers *>( imageSubresources.data() ) );
18844  }
18845 
18846  //=== VK_NV_memory_decompression ===
18847 
18848  VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV(
18849  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT
18850  {
18851  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryNV &&
18852  "Function <vkCmdDecompressMemoryNV> needs extension <VK_NV_memory_decompression> enabled!" );
18853 
18854  getDispatcher()->vkCmdDecompressMemoryNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18855  decompressMemoryRegions.size(),
18856  reinterpret_cast<const VkDecompressMemoryRegionNV *>( decompressMemoryRegions.data() ) );
18857  }
18858 
18859  VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,
18860  VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,
18861  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
18862  {
18864  "Function <vkCmdDecompressMemoryIndirectCountNV> needs extension <VK_NV_memory_decompression> enabled!" );
18865 
18866  getDispatcher()->vkCmdDecompressMemoryIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18867  static_cast<VkDeviceAddress>( indirectCommandsAddress ),
18868  static_cast<VkDeviceAddress>( indirectCommandsCountAddress ),
18869  stride );
18870  }
18871 
18872  //=== VK_EXT_extended_dynamic_state3 ===
18873 
18874  VULKAN_HPP_INLINE void
18875  CommandBuffer::setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
18876  {
18878  "Function <vkCmdSetTessellationDomainOriginEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18879 
18880  getDispatcher()->vkCmdSetTessellationDomainOriginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18881  static_cast<VkTessellationDomainOrigin>( domainOrigin ) );
18882  }
18883 
18884  VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
18885  {
18886  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampEnableEXT &&
18887  "Function <vkCmdSetDepthClampEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18888 
18889  getDispatcher()->vkCmdSetDepthClampEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClampEnable ) );
18890  }
18891 
18892  VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT
18893  {
18894  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPolygonModeEXT &&
18895  "Function <vkCmdSetPolygonModeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18896 
18897  getDispatcher()->vkCmdSetPolygonModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPolygonMode>( polygonMode ) );
18898  }
18899 
18900  VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT
18901  {
18903  "Function <vkCmdSetRasterizationSamplesEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18904 
18905  getDispatcher()->vkCmdSetRasterizationSamplesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18906  static_cast<VkSampleCountFlagBits>( rasterizationSamples ) );
18907  }
18908 
18909  VULKAN_HPP_INLINE void
18910  CommandBuffer::setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
18911  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask ) const VULKAN_HPP_NOEXCEPT
18912  {
18913  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleMaskEXT &&
18914  "Function <vkCmdSetSampleMaskEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18915 
18916  getDispatcher()->vkCmdSetSampleMaskEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18917  static_cast<VkSampleCountFlagBits>( samples ),
18918  reinterpret_cast<const VkSampleMask *>( sampleMask.data() ) );
18919  }
18920 
18921  VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT
18922  {
18924  "Function <vkCmdSetAlphaToCoverageEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18925 
18926  getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToCoverageEnable ) );
18927  }
18928 
18929  VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT
18930  {
18931  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToOneEnableEXT &&
18932  "Function <vkCmdSetAlphaToOneEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18933 
18934  getDispatcher()->vkCmdSetAlphaToOneEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToOneEnable ) );
18935  }
18936 
18937  VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT
18938  {
18939  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEnableEXT &&
18940  "Function <vkCmdSetLogicOpEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18941 
18942  getDispatcher()->vkCmdSetLogicOpEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( logicOpEnable ) );
18943  }
18944 
18945  VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT(
18946  uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT
18947  {
18948  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEnableEXT &&
18949  "Function <vkCmdSetColorBlendEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18950 
18951  getDispatcher()->vkCmdSetColorBlendEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18952  firstAttachment,
18953  colorBlendEnables.size(),
18954  reinterpret_cast<const VkBool32 *>( colorBlendEnables.data() ) );
18955  }
18956 
18957  VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT(
18958  uint32_t firstAttachment,
18959  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations ) const VULKAN_HPP_NOEXCEPT
18960  {
18962  "Function <vkCmdSetColorBlendEquationEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18963 
18964  getDispatcher()->vkCmdSetColorBlendEquationEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18965  firstAttachment,
18966  colorBlendEquations.size(),
18967  reinterpret_cast<const VkColorBlendEquationEXT *>( colorBlendEquations.data() ) );
18968  }
18969 
18970  VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT(
18971  uint32_t firstAttachment,
18972  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks ) const VULKAN_HPP_NOEXCEPT
18973  {
18974  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteMaskEXT &&
18975  "Function <vkCmdSetColorWriteMaskEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18976 
18977  getDispatcher()->vkCmdSetColorWriteMaskEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18978  firstAttachment,
18979  colorWriteMasks.size(),
18980  reinterpret_cast<const VkColorComponentFlags *>( colorWriteMasks.data() ) );
18981  }
18982 
18983  VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
18984  {
18986  "Function <vkCmdSetRasterizationStreamEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18987 
18988  getDispatcher()->vkCmdSetRasterizationStreamEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), rasterizationStream );
18989  }
18990 
18991  VULKAN_HPP_INLINE void CommandBuffer::setConservativeRasterizationModeEXT(
18992  VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT
18993  {
18995  "Function <vkCmdSetConservativeRasterizationModeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18996 
18997  getDispatcher()->vkCmdSetConservativeRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18998  static_cast<VkConservativeRasterizationModeEXT>( conservativeRasterizationMode ) );
18999  }
19000 
19001  VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT
19002  {
19004  "Function <vkCmdSetExtraPrimitiveOverestimationSizeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19005 
19006  getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), extraPrimitiveOverestimationSize );
19007  }
19008 
19009  VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT
19010  {
19011  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipEnableEXT &&
19012  "Function <vkCmdSetDepthClipEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19013 
19014  getDispatcher()->vkCmdSetDepthClipEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClipEnable ) );
19015  }
19016 
19017  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT
19018  {
19020  "Function <vkCmdSetSampleLocationsEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19021 
19022  getDispatcher()->vkCmdSetSampleLocationsEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( sampleLocationsEnable ) );
19023  }
19024 
19025  VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT(
19026  uint32_t firstAttachment,
19027  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT
19028  {
19030  "Function <vkCmdSetColorBlendAdvancedEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19031 
19032  getDispatcher()->vkCmdSetColorBlendAdvancedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
19033  firstAttachment,
19034  colorBlendAdvanced.size(),
19035  reinterpret_cast<const VkColorBlendAdvancedEXT *>( colorBlendAdvanced.data() ) );
19036  }
19037 
19038  VULKAN_HPP_INLINE void
19039  CommandBuffer::setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT
19040  {
19042  "Function <vkCmdSetProvokingVertexModeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19043 
19044  getDispatcher()->vkCmdSetProvokingVertexModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
19045  static_cast<VkProvokingVertexModeEXT>( provokingVertexMode ) );
19046  }
19047 
19048  VULKAN_HPP_INLINE void
19049  CommandBuffer::setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT
19050  {
19052  "Function <vkCmdSetLineRasterizationModeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19053 
19054  getDispatcher()->vkCmdSetLineRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
19055  static_cast<VkLineRasterizationModeEXT>( lineRasterizationMode ) );
19056  }
19057 
19058  VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT
19059  {
19060  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEnableEXT &&
19061  "Function <vkCmdSetLineStippleEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19062 
19063  getDispatcher()->vkCmdSetLineStippleEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stippledLineEnable ) );
19064  }
19065 
19066  VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT
19067  {
19069  "Function <vkCmdSetDepthClipNegativeOneToOneEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19070 
19071  getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( negativeOneToOne ) );
19072  }
19073 
19074  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT
19075  {
19077  "Function <vkCmdSetViewportWScalingEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19078 
19079  getDispatcher()->vkCmdSetViewportWScalingEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( viewportWScalingEnable ) );
19080  }
19081 
19082  VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV(
19083  uint32_t firstViewport,
19084  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles ) const VULKAN_HPP_NOEXCEPT
19085  {
19086  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportSwizzleNV &&
19087  "Function <vkCmdSetViewportSwizzleNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19088 
19089  getDispatcher()->vkCmdSetViewportSwizzleNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19090  firstViewport,
19091  viewportSwizzles.size(),
19092  reinterpret_cast<const VkViewportSwizzleNV *>( viewportSwizzles.data() ) );
19093  }
19094 
19095  VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT
19096  {
19098  "Function <vkCmdSetCoverageToColorEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19099 
19100  getDispatcher()->vkCmdSetCoverageToColorEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( coverageToColorEnable ) );
19101  }
19102 
19103  VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT
19104  {
19106  "Function <vkCmdSetCoverageToColorLocationNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19107 
19108  getDispatcher()->vkCmdSetCoverageToColorLocationNV( static_cast<VkCommandBuffer>( m_commandBuffer ), coverageToColorLocation );
19109  }
19110 
19111  VULKAN_HPP_INLINE void
19112  CommandBuffer::setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT
19113  {
19115  "Function <vkCmdSetCoverageModulationModeNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19116 
19117  getDispatcher()->vkCmdSetCoverageModulationModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19118  static_cast<VkCoverageModulationModeNV>( coverageModulationMode ) );
19119  }
19120 
19121  VULKAN_HPP_INLINE void
19122  CommandBuffer::setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT
19123  {
19125  "Function <vkCmdSetCoverageModulationTableEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19126 
19127  getDispatcher()->vkCmdSetCoverageModulationTableEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19128  static_cast<VkBool32>( coverageModulationTableEnable ) );
19129  }
19130 
19131  VULKAN_HPP_INLINE void
19132  CommandBuffer::setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT
19133  {
19135  "Function <vkCmdSetCoverageModulationTableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19136 
19137  getDispatcher()->vkCmdSetCoverageModulationTableNV(
19138  static_cast<VkCommandBuffer>( m_commandBuffer ), coverageModulationTable.size(), coverageModulationTable.data() );
19139  }
19140 
19141  VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT
19142  {
19144  "Function <vkCmdSetShadingRateImageEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19145 
19146  getDispatcher()->vkCmdSetShadingRateImageEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( shadingRateImageEnable ) );
19147  }
19148 
19149  VULKAN_HPP_INLINE void
19150  CommandBuffer::setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT
19151  {
19153  "Function <vkCmdSetRepresentativeFragmentTestEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19154 
19155  getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19156  static_cast<VkBool32>( representativeFragmentTestEnable ) );
19157  }
19158 
19159  VULKAN_HPP_INLINE void
19160  CommandBuffer::setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT
19161  {
19163  "Function <vkCmdSetCoverageReductionModeNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19164 
19165  getDispatcher()->vkCmdSetCoverageReductionModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19166  static_cast<VkCoverageReductionModeNV>( coverageReductionMode ) );
19167  }
19168 
19169  //=== VK_EXT_shader_module_identifier ===
19170 
19171  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT ShaderModule::getIdentifierEXT() const VULKAN_HPP_NOEXCEPT
19172  {
19174  "Function <vkGetShaderModuleIdentifierEXT> needs extension <VK_EXT_shader_module_identifier> enabled!" );
19175 
19177  getDispatcher()->vkGetShaderModuleIdentifierEXT(
19178  static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( m_shaderModule ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) );
19179 
19180  return identifier;
19181  }
19182 
19184  Device::getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
19185  {
19187  "Function <vkGetShaderModuleCreateInfoIdentifierEXT> needs extension <VK_EXT_shader_module_identifier> enabled!" );
19188 
19190  getDispatcher()->vkGetShaderModuleCreateInfoIdentifierEXT( static_cast<VkDevice>( m_device ),
19191  reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
19192  reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) );
19193 
19194  return identifier;
19195  }
19196 
19197  //=== VK_NV_optical_flow ===
19198 
19199  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>
19200  PhysicalDevice::getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const
19201  {
19203  "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> needs extension <VK_NV_optical_flow> enabled!" );
19204 
19205  std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> imageFormatProperties;
19206  uint32_t formatCount;
19207  VkResult result;
19208  do
19209  {
19210  result = getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
19211  static_cast<VkPhysicalDevice>( m_physicalDevice ),
19212  reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ),
19213  &formatCount,
19214  nullptr );
19215  if ( ( result == VK_SUCCESS ) && formatCount )
19216  {
19217  imageFormatProperties.resize( formatCount );
19218  result = getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
19219  static_cast<VkPhysicalDevice>( m_physicalDevice ),
19220  reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ),
19221  &formatCount,
19222  reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( imageFormatProperties.data() ) );
19223  }
19224  } while ( result == VK_INCOMPLETE );
19225  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" );
19226  VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() );
19227  if ( formatCount < imageFormatProperties.size() )
19228  {
19229  imageFormatProperties.resize( formatCount );
19230  }
19231  return imageFormatProperties;
19232  }
19233 
19235  Device::createOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo,
19237  {
19238  return VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV( *this, createInfo, allocator );
19239  }
19240 
19241  VULKAN_HPP_INLINE void OpticalFlowSessionNV::bindImage( VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
19243  VULKAN_HPP_NAMESPACE::ImageLayout layout ) const
19244  {
19246  "Function <vkBindOpticalFlowSessionImageNV> needs extension <VK_NV_optical_flow> enabled!" );
19247 
19248  VkResult result = getDispatcher()->vkBindOpticalFlowSessionImageNV( static_cast<VkDevice>( m_device ),
19249  static_cast<VkOpticalFlowSessionNV>( m_session ),
19250  static_cast<VkOpticalFlowSessionBindingPointNV>( bindingPoint ),
19251  static_cast<VkImageView>( view ),
19252  static_cast<VkImageLayout>( layout ) );
19253  resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::OpticalFlowSessionNV::bindImage" );
19254  }
19255 
19256  VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
19257  const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT
19258  {
19259  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdOpticalFlowExecuteNV && "Function <vkCmdOpticalFlowExecuteNV> needs extension <VK_NV_optical_flow> enabled!" );
19260 
19261  getDispatcher()->vkCmdOpticalFlowExecuteNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19262  static_cast<VkOpticalFlowSessionNV>( session ),
19263  reinterpret_cast<const VkOpticalFlowExecuteInfoNV *>( &executeInfo ) );
19264  }
19265 
19266  //=== VK_QCOM_tile_properties ===
19267 
19268  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> Framebuffer::getTilePropertiesQCOM() const
19269  {
19271  "Function <vkGetFramebufferTilePropertiesQCOM> needs extension <VK_QCOM_tile_properties> enabled!" );
19272 
19273  std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> properties;
19274  uint32_t propertiesCount;
19275  VkResult result;
19276  do
19277  {
19278  result = getDispatcher()->vkGetFramebufferTilePropertiesQCOM(
19279  static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( m_framebuffer ), &propertiesCount, nullptr );
19280  if ( ( result == VK_SUCCESS ) && propertiesCount )
19281  {
19282  properties.resize( propertiesCount );
19283  result = getDispatcher()->vkGetFramebufferTilePropertiesQCOM( static_cast<VkDevice>( m_device ),
19284  static_cast<VkFramebuffer>( m_framebuffer ),
19285  &propertiesCount,
19286  reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) );
19287  }
19288  } while ( result == VK_INCOMPLETE );
19289 
19290  VULKAN_HPP_ASSERT( propertiesCount <= properties.size() );
19291  if ( propertiesCount < properties.size() )
19292  {
19293  properties.resize( propertiesCount );
19294  }
19295  return properties;
19296  }
19297 
19299  Device::getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT
19300  {
19302  "Function <vkGetDynamicRenderingTilePropertiesQCOM> needs extension <VK_QCOM_tile_properties> enabled!" );
19303 
19305  getDispatcher()->vkGetDynamicRenderingTilePropertiesQCOM( static_cast<VkDevice>( m_device ),
19306  reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ),
19307  reinterpret_cast<VkTilePropertiesQCOM *>( &properties ) );
19308 
19309  return properties;
19310  }
19311 
19312  } // namespace VULKAN_HPP_RAII_NAMESPACE
19313 } // namespace VULKAN_HPP_NAMESPACE
19314 #endif
19315 #endif
void(VKAPI_PTR * PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:6380
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
GLsizei GLenum GLsizei GLsizei GLuint memory
Definition: RE_OGL.h:202
void(VKAPI_PTR * PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:6385
PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV
void swap(ArAssetInfo &lhs, ArAssetInfo &rhs)
Definition: assetInfo.h:74
VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
VkResult(VKAPI_PTR * PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:3972
void(VKAPI_PTR * PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
Definition: glcorearb.h:2621
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
Definition: vulkan_core.h:7305
VkResult(VKAPI_PTR * PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay)
CommandBuffer(CommandBuffer &&rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
Definition: vulkan_core.h:3927
VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(VkDevice device)
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)
VkResult(VKAPI_PTR * PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display)
SwapchainKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkSwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR
VkResult(VKAPI_PTR * PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
GLenum query
Definition: glad.h:2772
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
Definition: vulkan_core.h:9696
AccelerationStructureKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkAccelerationStructureKHR accelerationStructure, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
DescriptorUpdateTemplate(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PhysicalDevice(PhysicalDevice &&rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:8956
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)
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)
void(VKAPI_PTR * PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4])
Definition: vulkan_core.h:4004
PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR
VkResult(VKAPI_PTR * PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
Definition: vulkan_core.h:9150
VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT *pMetalObjectsInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
GLuint GLsizei const GLchar * message
Definition: glcorearb.h:2543
Mat3< typename promote< S, T >::type > operator*(S scalar, const Mat3< T > &m)
Multiply each element of the given matrix by scalar and return the result.
Definition: Mat3.h:561
VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
ILMTHREAD_EXPORT Semaphore(unsigned int value=0)
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties
void(VKAPI_PTR * PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
VULKAN_HPP_NAMESPACE::BufferView const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display *display)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:4041
VkResult(VKAPI_PTR * PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
Definition: vulkan_core.h:3917
PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV
VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const VULKAN_HPP_NOEXCEPT
DisplayModeKHR & operator=(DisplayModeKHR &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:9789
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id)
Definition: vulkan_xcb.h:35
PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
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)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle)
void(VKAPI_PTR * PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3987
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
Definition: vulkan_core.h:9449
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
GLbitfield flags
Definition: glcorearb.h:1596
PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT
void(VKAPI_PTR * PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
Definition: vulkan_core.h:4003
PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR
void(VKAPI_PTR * PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
DescriptorSet(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool)
VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
RenderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkRenderPass renderPass, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VkResult(VKAPI_PTR * PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
Definition: vulkan_core.h:7294
PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
Definition: vulkan_core.h:8759
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceLayerProperties)(uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:3921
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
void(VKAPI_PTR * PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
Definition: vulkan_core.h:4006
VkResult(VKAPI_PTR * PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
Definition: vulkan_win32.h:197
PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT
PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT
DescriptorPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkDescriptorPool descriptorPool, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VkResult(VKAPI_PTR * PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
Definition: vulkan_core.h:3943
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts)
VkResult(VKAPI_PTR * PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
Definition: vulkan_core.h:9353
VkResult(VKAPI_PTR * PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
Definition: vulkan_core.h:9299
void(VKAPI_PTR * PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3989
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
Definition: vulkan_win32.h:154
VkResult(VKAPI_PTR * PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_xlib.h:34
PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR
void(VKAPI_PTR * PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:3937
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
VkResult(VKAPI_PTR * PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT
VkResult(VKAPI_PTR * PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR
void(VKAPI_PTR * PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
VkResult(VKAPI_PTR * PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain)
Definition: vulkan_win32.h:287
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
void(VKAPI_PTR * PFN_vkUninitializePerformanceApiINTEL)(VkDevice device)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
OpticalFlowSessionNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkOpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
uint32_t VkBool32
Definition: vulkan_core.h:93
PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT
VkResult(VKAPI_PTR * PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
VULKAN_HPP_NAMESPACE::RenderPass const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7589
PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR
PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR
void(VKAPI_PTR * PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2EXT *pSubresource, VkSubresourceLayout2EXT *pLayout)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV &rhs) VULKAN_HPP_NOEXCEPT
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR &rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR *pModes)
Definition: vulkan_win32.h:288
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
void(VKAPI_PTR * PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
Definition: vulkan_core.h:4027
void(VKAPI_PTR * PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV
VULKAN_HPP_NAMESPACE::SurfaceKHR const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
void(VKAPI_PTR * PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool &rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
VkResult(VKAPI_PTR * PFN_vkResetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3952
Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, uint32_t queueFamilyIndex, uint32_t queueIndex)
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:200
VkResult(VKAPI_PTR * PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:3955
void(VKAPI_PTR * PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
Definition: vulkan_core.h:7323
void(VKAPI_PTR * PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3959
void(VKAPI_PTR * PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
void(VKAPI_PTR * PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR &rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:8310
void(VKAPI_PTR * PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
Definition: vulkan_core.h:7322
VkResult
Definition: vulkan_core.h:139
VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
void(VKAPI_PTR * PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
Definition: vulkan_core.h:7308
PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD
VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
void(VKAPI_PTR * PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
Definition: vulkan_core.h:7310
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR
SamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkSamplerYcbcrConversion ycbcrConversion, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
void(VKAPI_PTR * PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
void(VKAPI_PTR * PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window *window)
Framebuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkFramebuffer framebuffer, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
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)
void(VKAPI_PTR * PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5552
math::Stats statistics(const IterT &iter, bool threaded=true)
Iterate over a scalar grid and compute statistics (mean, variance, etc.) of the values of the voxels ...
Definition: Statistics.h:362
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts)
Y
Definition: ImathEuler.h:184
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance &rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
QueryPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkQueryPool queryPool, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
__hostdev__ SampleFromVoxels< TreeOrAccT, Order, UseCache > createSampler(const TreeOrAccT &acc)
Factory free-function for a sampler of specific polynomial orders.
VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const VULKAN_HPP_NOEXCEPT
DebugUtilsMessengerEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, VkDebugUtilsMessengerEXT messenger, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6376
void(VKAPI_PTR * PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
void(VKAPI_PTR * PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:4015
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:8036
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties
Queue & operator=(Queue &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
MicromapEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkMicromapEXT micromap, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
void(VKAPI_PTR * PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT
void(VKAPI_PTR * PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VkResult(VKAPI_PTR * PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
Definition: vulkan_core.h:3945
void(VKAPI_PTR * PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
GLboolean * data
Definition: glcorearb.h:131
void swap(UT::ArraySet< Key, MULTI, MAX_LOAD_FACTOR_256, Clearer, Hash, KeyEqual > &a, UT::ArraySet< Key, MULTI, MAX_LOAD_FACTOR_256, Clearer, Hash, KeyEqual > &b)
Definition: UT_ArraySet.h:1639
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet &rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
VkResult(VKAPI_PTR * PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
Definition: vulkan_core.h:7861
VkResult(VKAPI_PTR * PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
Definition: vulkan_core.h:3941
void(VKAPI_PTR * PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR &rhs) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:8103
void(VKAPI_PTR * PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer)
PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR
VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT
void(VKAPI_PTR * PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
void(VKAPI_PTR * PFN_vkDestroyBufferCollectionFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle)
Definition: vulkan_win32.h:228
PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
PerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkPerformanceConfigurationINTEL configuration)
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:9330
VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
IndirectCommandsLayoutNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkIndirectCommandsLayoutNV indirectCommandsLayout, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
void(VKAPI_PTR * PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth)
Definition: vulkan_core.h:4002
DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, VkDisplayKHR display)
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VULKAN_HPP_NAMESPACE::Fence const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
Definition: vulkan_core.h:3962
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
VkResult(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VkResult(VKAPI_PTR * PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
Definition: vulkan_core.h:3967
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT &rhs) VULKAN_HPP_NOEXCEPT
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
Definition: vulkan_core.h:7319
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display)
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)
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
VkResult(VKAPI_PTR * PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
Definition: vulkan_core.h:7862
VkResult(VKAPI_PTR * PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
void(VKAPI_PTR * PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:8408
ValidationCacheEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkValidationCacheEXT validationCache, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
void(VKAPI_PTR * PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:9991
GLsizei const GLchar *const * string
Definition: glcorearb.h:814
GLsizei const GLfloat * value
Definition: glcorearb.h:824
void(VKAPI_PTR * PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pDecodeInfo)
Definition: vulkan_beta.h:363
void(VKAPI_PTR * PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
Definition: vulkan_core.h:9563
VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA *pProperties)
Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkQueue queue)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & operator*() const VULKAN_HPP_NOEXCEPT
CommandPool(CommandPool &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
Definition: vulkan_core.h:7307
DisplayModeKHR & operator=(DisplayModeKHR const &rhs)
VkResult(VKAPI_PTR * PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
Definition: vulkan_core.h:3970
void(VKAPI_PTR * PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:4000
VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
Definition: vulkan_core.h:3938
VULKAN_HPP_NAMESPACE::Queue const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
Definition: vulkan_core.h:3909
void(VKAPI_PTR * PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3957
VULKAN_HPP_NAMESPACE::Image const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
VULKAN_HPP_NAMESPACE::Instance getInstance() const
DescriptorSets(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const &allocateInfo)
T const * data() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:684
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR &rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
GLuint64 GLenum handleType
Definition: RE_OGL.h:262
VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
void(VKAPI_PTR * PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
Definition: vulkan_core.h:9693
PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT
PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
void(VKAPI_PTR * PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
void(VKAPI_PTR * PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3979
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:8994
VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
#define VULKAN_HPP_RAII_NAMESPACE
Definition: vulkan_raii.hpp:16
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:5543
PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion(uint32_t *pApiVersion, Dispatch const &d) VULKAN_HPP_NOEXCEPT
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion &rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
void(VKAPI_PTR * PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
Definition: vulkan_core.h:7302
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
Definition: vulkan_core.h:3914
VkResult(VKAPI_PTR * PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
uint64_t DeviceAddress
Definition: vulkan.hpp:6074
void(VKAPI_PTR * PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
Definition: vulkan_core.h:7297
VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
void(VKAPI_PTR * PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetDeviceProcAddr)(VkDevice device, const char *pName)
Definition: vulkan_core.h:3916
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:5557
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, zx_handle_t *pZirconHandle)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
Definition: vulkan_core.h:7987
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
VkFlags VkColorComponentFlags
Definition: vulkan_core.h:2541
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR
ImageView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkImageView imageView, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:8035
PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR
VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
Definition: vulkan_core.h:7729
VkResult(VKAPI_PTR * PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
void(VKAPI_PTR * PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
ILMTHREAD_EXPORT int value() const
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:8269
DisplayKHRs(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, uint32_t planeIndex)
PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
Definition: vulkan_core.h:7591
VkResult(VKAPI_PTR * PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
Definition: vulkan_core.h:3969
void(VKAPI_PTR * PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
void(VKAPI_PTR * PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR
VkResult(VKAPI_PTR * PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR
PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV
void(VKAPI_PTR * PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
void(VKAPI_PTR * PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkReleaseProfilingLockKHR)(VkDevice device)
Definition: vulkan_core.h:8692
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
void(VKAPI_PTR * PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
DescriptorSet(DescriptorSet &&rhs) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
VkResult(VKAPI_PTR * PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
Definition: vulkan_core.h:8691
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:5556
VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
void(VKAPI_PTR * PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR *pVideoProfile, VkVideoCapabilitiesKHR *pCapabilities)
Definition: vulkan_beta.h:240
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:9892
void(VKAPI_PTR * PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:6381
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
Definition: vulkan_core.h:7592
VkResult(VKAPI_PTR * PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_vi.h:33
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
VkResult(VKAPI_PTR * PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
Definition: vulkan_core.h:7731
X
Definition: ImathEuler.h:183
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
Definition: vulkan_core.h:8819
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:5542
VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionParametersKHR *pVideoSessionParameters)
VkResult(VKAPI_PTR * PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL release()
void(VKAPI_PTR * PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority)
void(VKAPI_PTR * PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT
CuModuleNVX(CuModuleNVX &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
Definition: vulkan_core.h:4039
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT
void(VKAPI_PTR * PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
Definition: vulkan_core.h:7291
PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress
PhysicalDevice & operator=(PhysicalDevice const &rhs)
PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo, struct AHardwareBuffer **pBuffer)
PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI
DescriptorSetLayout(DescriptorSetLayout &&rhs) VULKAN_HPP_NOEXCEPT
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
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)
VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA *pBufferConstraintsInfo)
void(VKAPI_PTR * PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
Definition: vulkan_core.h:7859
PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR
void(VKAPI_PTR * PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
GLenum GLenum GLsizei void * image
Definition: glad.h:5132
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
void(VKAPI_PTR * PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
Definition: vulkan_core.h:4013
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VkResult(VKAPI_PTR * PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VkFlags VkPipelineStageFlags
Definition: vulkan_core.h:2401
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
**But if you need a result
Definition: thread.h:613
void(VKAPI_PTR * PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
VkResult(VKAPI_PTR * PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
void(VKAPI_PTR * PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
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)
VkResult(VKAPI_PTR * PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer)
PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR
VkResult(VKAPI_PTR * PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
Definition: vulkan_core.h:9891
VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
DeferredOperationKHR(DeferredOperationKHR &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:8034
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
Definition: vulkan_core.h:9451
PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR
void(VKAPI_PTR * PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
VULKAN_HPP_NAMESPACE::PrivateDataSlot const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT *pMetalObjectsInfo)
Definition: vulkan_metal.h:181
VkResult(VKAPI_PTR * PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
AccelerationStructureKHR(AccelerationStructureKHR &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
void(VKAPI_PTR * PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
Definition: vulkan_core.h:4024
GLuint sampler
Definition: glcorearb.h:1656
VkResult(VKAPI_PTR * PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE
PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE
void(VKAPI_PTR * PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:5536
VkResult(VKAPI_PTR * PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
void(VKAPI_PTR * PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
void(VKAPI_PTR * PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
Definition: vulkan_core.h:7298
void(VKAPI_PTR * PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:4029
PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR
VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
Definition: vulkan_core.h:8309
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy, VisualID visualID)
Definition: vulkan_xlib.h:35
void(VKAPI_PTR * PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
Definition: vulkan_core.h:7303
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
AccelerationStructureNV(AccelerationStructureNV &&rhs) VULKAN_HPP_NOEXCEPT
const GLuint * pipelines
Definition: glcorearb.h:1935
DeviceMemory(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkDeviceMemory memory, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT *pSubresource, VkSubresourceLayout2EXT *pLayout)
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:8881
VkResult(VKAPI_PTR * PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
void(VKAPI_PTR * PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_beta.h:248
PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR
void(VKAPI_PTR * PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3961
VkResult(VKAPI_PTR * PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
Definition: vulkan_core.h:3958
VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo)
VkResult(VKAPI_PTR * PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
GLuint buffer
Definition: glcorearb.h:660
PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV
VkResult(VKAPI_PTR * PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:3971
VULKAN_HPP_NAMESPACE::Device getDevice() const
void(VKAPI_PTR * PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
Definition: vulkan_core.h:7316
VkResult(VKAPI_PTR * PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:7296
PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain)
VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(VkDevice device)
DescriptorSetLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkDescriptorSetLayout descriptorSetLayout, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VkResult(VKAPI_PTR * PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
Definition: vulkan_win32.h:315
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo)
PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
Definition: vulkan_core.h:7593
VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:5533
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
void(VKAPI_PTR * PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6375
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
Definition: vulkan_core.h:7858
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:5555
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:8032
VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView &rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
void(VKAPI_PTR * PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:9992
VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
VkResult(VKAPI_PTR * PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties)
PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR
VkResult(VKAPI_PTR * PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
void(VKAPI_PTR * PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
Definition: vulkan_core.h:4008
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)
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB *dfb)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT
PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
void(VKAPI_PTR * PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
VkResult(VKAPI_PTR * PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display)
PipelineLayout(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkPipelineLayout pipelineLayout, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:7325
void(VKAPI_PTR * PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
Definition: vulkan_core.h:4009
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)
SwapchainKHR(SwapchainKHR &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo)
PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
Definition: vulkan_core.h:4032
PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5539
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Semaphore(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkSemaphore semaphore, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
Definition: vulkan_core.h:9694
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT &rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
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)
VkResult(VKAPI_PTR * PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionParametersKHR *pVideoSessionParameters)
Definition: vulkan_beta.h:246
GLuint GLsizei const GLuint const GLintptr * offsets
Definition: glcorearb.h:2621
PipelineCache(PipelineCache &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferCollectionFUCHSIA *pCollection)
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
Definition: vulkan_core.h:7312
void(VKAPI_PTR * PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
struct _cl_event * event
Definition: glcorearb.h:2961
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VkResult(VKAPI_PTR * PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VkResult(VKAPI_PTR * PFN_vkSetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3951
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
DebugReportCallbackEXT(DebugReportCallbackEXT &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3981
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)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
VkResult(VKAPI_PTR * PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
Definition: vulkan_core.h:3940
VkResult(VKAPI_PTR * PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession)
Definition: vulkan_beta.h:242
VULKAN_HPP_NAMESPACE::DescriptorPool const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkCreateInstance)(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
Definition: vulkan_core.h:3906
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
void(VKAPI_PTR * PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
Buffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkBuffer buffer, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
Definition: vulkan_core.h:9149
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
VkResult(VKAPI_PTR * PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:3984
IMFUTIL_EXPORT Image()
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
void(VKAPI_PTR * PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
VkResult(VKAPI_PTR * PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
VULKAN_HPP_NAMESPACE::Device getDevice() const
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PipelineLayout(PipelineLayout &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
VkResult(VKAPI_PTR * PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements)
Definition: vulkan_beta.h:244
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)
PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate
VkResult(VKAPI_PTR * PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:3935
PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV
void(VKAPI_PTR * PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3992
VULKAN_HPP_NAMESPACE::DescriptorSet const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkQueueWaitIdle)(VkQueue queue)
Definition: vulkan_core.h:3925
PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory &rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:8406
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:8879
VkResult(VKAPI_PTR * PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
Definition: vulkan_core.h:3948
VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
void(VKAPI_PTR * PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT
void(VKAPI_PTR * PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
Definition: vulkan_core.h:3939
VkResult(VKAPI_PTR * PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:8562
PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR
PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements
void(VKAPI_PTR * PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:8033
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:5534
void(VKAPI_PTR * PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7724
GLint GLsizei GLsizei height
Definition: glcorearb.h:103
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
Definition: vulkan_win32.h:82
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
Definition: vulkan_core.h:7315
PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT
PrivateDataSlot(PrivateDataSlot &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
void(VKAPI_PTR * PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:5535
void(VKAPI_PTR * PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5554
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)
PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT
DisplayModeKHR(DisplayModeKHR &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
void(VKAPI_PTR * PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
Definition: vulkan_core.h:4007
#define VULKAN_HPP_CONST_OR_CONSTEXPR
Definition: vulkan.hpp:193
uint64_t(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:9331
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
void(VKAPI_PTR * PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
Definition: vulkan_core.h:4012
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
ShaderModule(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkShaderModule shaderModule, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
GLuint framebuffer
Definition: glcorearb.h:1287
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:9565
VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
void(VKAPI_PTR * PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo)
Definition: vulkan_beta.h:251
PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR
VULKAN_HPP_NAMESPACE::Buffer const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
Definition: vulkan_core.h:7590
VULKAN_HPP_NAMESPACE::MicromapEXT const & operator*() const VULKAN_HPP_NOEXCEPT
PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR
PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:8957
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM
VkResult(VKAPI_PTR * PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_ggp.h:33
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
Definition: vulkan_core.h:9695
VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
VULKAN_HPP_NAMESPACE::PipelineLayout const & operator*() const VULKAN_HPP_NOEXCEPT
GLintptr offset
Definition: glcorearb.h:665
void(VKAPI_PTR * PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
Definition: vulkan_core.h:7321
PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV
VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos)
VkResult(VKAPI_PTR * PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_xcb.h:34
VkResult(VKAPI_PTR * PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
Definition: vulkan_core.h:3929
VkResult(VKAPI_PTR * PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
Definition: vulkan_core.h:3956
PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR
PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR
Definition: core.h:760
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)
VULKAN_HPP_NODISCARD std::vector< VULKAN_HPP_NAMESPACE::ExtensionProperties > enumerateInstanceExtensionProperties(Optional< const std::string > layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const
PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:8995
PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate
VkResult(VKAPI_PTR * PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
Definition: vulkan_core.h:3996
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties)
Definition: vulkan_win32.h:83
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR
GLboolean reset
Definition: glad.h:5138
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)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
void(VKAPI_PTR * PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:7313
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
OpticalFlowSessionNV(OpticalFlowSessionNV &&rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
Definition: vulkan_core.h:8689
PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR
void(VKAPI_PTR * PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
VkResult(VKAPI_PTR * PFN_vkCreateDirectFBSurfaceEXT)(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
bool empty() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:674
VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
VkResult(VKAPI_PTR * PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
void(VKAPI_PTR * PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
void(VKAPI_PTR * PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
Definition: vulkan_core.h:4010
PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL
DisplayKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, int32_t drmFd, uint32_t connectorId)
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
Definition: vulkan_core.h:3913
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VkResult(VKAPI_PTR * PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
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)
VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
#define VULKAN_HPP_NAMESPACE
Definition: vulkan.hpp:229
VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const VULKAN_HPP_NOEXCEPT
DescriptorUpdateTemplate(DescriptorUpdateTemplate &&rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkDeviceWaitIdle)(VkDevice device)
Definition: vulkan_core.h:3926
PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT
PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR
VkResult(VKAPI_PTR * PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
#define VULKAN_HPP_CONSTEXPR_14
Definition: vulkan.hpp:192
VkResult(VKAPI_PTR * PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
Definition: vulkan_core.h:6383
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
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)
void(VKAPI_PTR * PFN_vkVoidFunction)(void)
Definition: vulkan_core.h:2918
PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:6377
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT
void(VKAPI_PTR * PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:8101
void(VKAPI_PTR * PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:7327
GLbitfield GLuint64 timeout
Definition: glcorearb.h:1599
PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR
void(VKAPI_PTR * PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3928
VkResult(VKAPI_PTR * PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT &rhs) VULKAN_HPP_NOEXCEPT
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
VkResult(VKAPI_PTR * PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA *pBufferConstraintsInfo)
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:5541
PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo)
void(VKAPI_PTR * PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
void(VKAPI_PTR * PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:4026
Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const &queueInfo)
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)
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
void(VKAPI_PTR * PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:5537
VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::Instance createInstance(VULKAN_HPP_NAMESPACE::InstanceCreateInfo const &createInfo, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr) const
#define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
Definition: vulkan.hpp:5885
uint64_t(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:6386
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VkResult(VKAPI_PTR * PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:9356
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR *pModes)
VkResult(VKAPI_PTR * PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
DeferredOperationKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
uint32_t size() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:679
PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT
CuFunctionNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkCuFunctionNVX function, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:9566
VULKAN_HPP_NODISCARD std::vector< VULKAN_HPP_NAMESPACE::LayerProperties > enumerateInstanceLayerProperties() const
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VULKAN_HPP_NAMESPACE::CommandBuffer const & operator*() const VULKAN_HPP_NOEXCEPT
PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties
PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
Definition: vulkan_core.h:9568
VkResult(VKAPI_PTR * PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_core.h:7864
VkDeviceAddress(VKAPI_PTR * PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
Definition: vulkan_core.h:3915
VkResult(VKAPI_PTR * PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
DeviceMemory(DeviceMemory &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
GLuint GLuint end
Definition: glcorearb.h:475
void(VKAPI_PTR * PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV
void(VKAPI_PTR * PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo)
Definition: vulkan_beta.h:250
VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
void(VKAPI_PTR * PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:4042
Device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, VkDevice device, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT
void(VKAPI_PTR * PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3907
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceVersion)(uint32_t *pApiVersion)
Definition: vulkan_core.h:5532
void(VKAPI_PTR * PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR
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)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain)
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108
PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV
void(VKAPI_PTR * PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:4001
uint32_t(VKAPI_PTR * PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:9355
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT
void(VKAPI_PTR * PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:5538
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
VkResult(VKAPI_PTR * PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain)
Definition: vulkan_win32.h:286
Context(PFN_vkGetInstanceProcAddr getInstanceProcAddr)
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:3988
VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
VkResult(VKAPI_PTR * PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
GLint GLenum GLboolean GLsizei stride
Definition: glcorearb.h:872
VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:9790
const GLuint * buffers
Definition: glcorearb.h:661
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5540
void(VKAPI_PTR * PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3947
GLsizei const GLenum * attachments
Definition: glcorearb.h:2518
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
VkResult(VKAPI_PTR * PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains)
Definition: vulkan_core.h:7921
VkResult(VKAPI_PTR * PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, zx_handle_t *pZirconHandle)
void(VKAPI_PTR * PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
Definition: vulkan_core.h:3933
VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
void(VKAPI_PTR * PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR &rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
VULKAN_HPP_INLINE void resultCheck(Result result, char const *message)
Definition: vulkan.hpp:6639
PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV
void(VKAPI_PTR * PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:4025
PhysicalDevice & operator=(PhysicalDevice &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
Definition: vulkan_core.h:9569
PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT
VkResult(VKAPI_PTR * PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration)
void(VKAPI_PTR * PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain)
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
VkResult(VKAPI_PTR * PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:3932
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)
void(VKAPI_PTR * PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
Definition: vulkan_core.h:9764
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)
VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
void(VKAPI_PTR * PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:8462
VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:8932
PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT
VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT
PerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const &acquireInfo)
void(VKAPI_PTR * PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:5549
PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE
VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV
void(VKAPI_PTR * PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
void(VKAPI_PTR * PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3954
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress
void(VKAPI_PTR * PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the queue
Definition: thread.h:623
GLint location
Definition: glcorearb.h:805
VkResult(VKAPI_PTR * PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo)
Definition: vulkan_win32.h:196
#define VULKAN_HPP_ASSERT
Definition: vulkan.hpp:70
VULKAN_HPP_NAMESPACE::DisplayModeKHR const & operator*() const VULKAN_HPP_NOEXCEPT
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)
VkResult(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
void(VKAPI_PTR * PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
VULKAN_HPP_NAMESPACE::CommandPool const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR *pVideoProfile, VkVideoCapabilitiesKHR *pCapabilities)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR
void(VKAPI_PTR * PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
void(VKAPI_PTR * PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:9562
VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7293
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer &rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
PhysicalDevices(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
void(VKAPI_PTR * PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VkRemoteAddressNV *pAddress)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
VkResult(VKAPI_PTR * PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:3983
VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display *display)
VULKAN_HPP_NAMESPACE::CommandPool commandPool
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo)
VkResult(VKAPI_PTR * PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
void(VKAPI_PTR * PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
Definition: vulkan_core.h:3990
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
void(VKAPI_PTR * PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
Definition: vulkan_core.h:8461
PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE
VkResult(VKAPI_PTR * PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
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)
VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
PipelineCache(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkPipelineCache pipelineCache, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VkResult(VKAPI_PTR * PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
void(VKAPI_PTR * PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
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)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
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)
void trim(std::string &s)
Definition: Name.h:83
PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable
VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
void(VKAPI_PTR * PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
Definition: vulkan_core.h:9692
void(VKAPI_PTR * PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
Definition: vulkan_core.h:8334
void(VKAPI_PTR * PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
#define VULKAN_HPP_NODISCARD
Definition: vulkan.hpp:224
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VkResult(VKAPI_PTR * PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_metal.h:39
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo)
VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks *pAllocator)
GLuint const GLchar * name
Definition: glcorearb.h:786
VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV
VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const
PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV
void(VKAPI_PTR * PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_beta.h:243
VkResult(VKAPI_PTR * PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
Definition: vulkan_core.h:7301
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot &rhs) VULKAN_HPP_NOEXCEPT
CommandBuffers(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const &allocateInfo)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
VkResult(VKAPI_PTR * PFN_vkSetBufferCollectionImageConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA *pImageConstraintsInfo)
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
Definition: vulkan_core.h:7860
VkResult(VKAPI_PTR * PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
Definition: vulkan_core.h:7324
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
Definition: vulkan_core.h:3993
VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
void(VKAPI_PTR * PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
Definition: vulkan_core.h:4028
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
VkResult(VKAPI_PTR * PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
Definition: vulkan_core.h:7292
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
void(VKAPI_PTR * PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
VkResult(VKAPI_PTR * PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:5558
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline &rhs) VULKAN_HPP_NOEXCEPT
CommandPool(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkCommandPool commandPool, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
void(VKAPI_PTR * PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
void(VKAPI_PTR * PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
void(VKAPI_PTR * PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
Definition: vulkan_core.h:4038
PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
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)
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
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)
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
VkResult(VKAPI_PTR * PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:8880
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool &rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:8460
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
Definition: vulkan_core.h:3978
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
void(VKAPI_PTR * PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
void(VKAPI_PTR * PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
Definition: vulkan_core.h:3999
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VULKAN_HPP_NAMESPACE::PhysicalDevice const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties
Definition: vulkan_raii.hpp:56
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
VkResult(VKAPI_PTR * PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_macos.h:33
void(VKAPI_PTR * PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
Definition: vulkan_core.h:3912
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate &rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:9357
void(VKAPI_PTR * PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
Definition: vulkan_core.h:7306
void(VKAPI_PTR * PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
DescriptorPool(DescriptorPool &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:8140
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)
VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
void(VKAPI_PTR * PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
VkResult(VKAPI_PTR * PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
Definition: vulkan_core.h:7725
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)
PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:3936
VkResult(VKAPI_PTR * PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::ExtensionProperties *pProperties, Dispatch const &d) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
DisplayModeKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const &display, VkDisplayModeKHR displayModeKHR)
GLsizei samples
Definition: glcorearb.h:1298
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:5553
VkResult(VKAPI_PTR * PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:3994
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
GLenum mode
Definition: glcorearb.h:99
VkResult(VKAPI_PTR * PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
Definition: vulkan_core.h:7723
VkResult(VKAPI_PTR * PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
GLint GLint GLsizei GLsizei GLsizei depth
Definition: glcorearb.h:476
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
uint64_t(VKAPI_PTR * PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
Definition: vulkan_core.h:9332
VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
VULKAN_HPP_NAMESPACE::Event const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, zx_handle_t *pZirconHandle)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV
VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA *pImageConstraintsInfo)
PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR
VkResult(VKAPI_PTR * PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
void(VKAPI_PTR * PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3968
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:8037
void(VKAPI_PTR * PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3973
ShaderModule(ShaderModule &&rhs) VULKAN_HPP_NOEXCEPT
auto reserve(std::back_insert_iterator< Container > it, size_t n) -> checked_ptr< typename Container::value_type >
Definition: format.h:357
VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
VkResult(VKAPI_PTR * PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:7300
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image &rhs) VULKAN_HPP_NOEXCEPT
AccelerationStructureNV(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkAccelerationStructureNV accelerationStructure, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer &rhs) VULKAN_HPP_NOEXCEPT
static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo)
void(VKAPI_PTR * PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3918
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VkResult(VKAPI_PTR * PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
VkResult(VKAPI_PTR * PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout &rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
void(VKAPI_PTR * PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
Definition: vulkan_core.h:9697
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate release()
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:5559
PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties
Definition: vulkan_raii.hpp:55
void(VKAPI_PTR * PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:8102
PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport
MicromapEXT(MicromapEXT &&rhs) VULKAN_HPP_NOEXCEPT
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context &rhs)
PhysicalDevice(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, VkPhysicalDevice physicalDevice)
void(VKAPI_PTR * PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
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)
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
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)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
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)
PrivateDataSlot(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkPrivateDataSlot privateDataSlot, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
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)
void(VKAPI_PTR * PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
Definition: vulkan_core.h:9248
void(VKAPI_PTR * PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:3995
PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
GLsizeiptr size
Definition: glcorearb.h:664
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)
void(VKAPI_PTR * PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
GLenum GLenum dst
Definition: glcorearb.h:1793
void(VKAPI_PTR * PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:4014
void(VKAPI_PTR * PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
GLuint shader
Definition: glcorearb.h:785
PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
DeferredOperationKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkDeferredOperationKHR operation, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VkResult(VKAPI_PTR * PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
Definition: vulkan_core.h:3991
PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR
void(VKAPI_PTR * PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
Definition: vulkan_core.h:4019
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
GLsizeiptr const void GLenum usage
Definition: glcorearb.h:664
void(VKAPI_PTR * PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
Definition: vulkan_core.h:4023
VkResult(VKAPI_PTR * PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer)
void(VKAPI_PTR * PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
Definition: vulkan_core.h:7317
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window *window)
Definition: vulkan_screen.h:35
VkResult(VKAPI_PTR * PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:3931
VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
Definition: vulkan_core.h:9450
void(VKAPI_PTR * PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:4035
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
VkResult(VKAPI_PTR * PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
Definition: vulkan_core.h:7726
PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV
VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void(VKAPI_PTR * PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo)
Definition: vulkan_beta.h:503
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy, VisualID visualID)
VkResult(VKAPI_PTR * PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain)
Definition: vulkan_core.h:8497
void(VKAPI_PTR * PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
Definition: vulkan_core.h:4020
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:4036
#define VULKAN_HPP_NAMESPACE_STRING
Definition: vulkan.hpp:234
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
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)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
void(VKAPI_PTR * PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
Definition: vulkan_core.h:5550
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)
SamplerYcbcrConversion(SamplerYcbcrConversion &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
void(VKAPI_PTR * PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents)
Definition: vulkan_core.h:4040
GLenum GLsizei GLsizei GLint * values
Definition: glcorearb.h:1602
VkResult(VKAPI_PTR * PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
void(VKAPI_PTR * PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:4016
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:8521
PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
Definition: vulkan_win32.h:285
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL
VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
GLuint color
Definition: glcorearb.h:1261
VkResult(VKAPI_PTR * PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
VkResult(VKAPI_PTR * PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
Definition: vulkan_core.h:3953
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
VULKAN_HPP_NODISCARD uint32_t enumerateInstanceVersion() const
PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT
PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR
VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
void(VKAPI_PTR * PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:6379
VkResult(VKAPI_PTR * PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
void(VKAPI_PTR * PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
Definition: vulkan_core.h:9564
void(VKAPI_PTR * PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
VkResult(VKAPI_PTR * PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo, struct AHardwareBuffer **pBuffer)
void(VKAPI_PTR * PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:9791
VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
CuFunctionNVX(CuFunctionNVX &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:7326
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)
PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:5548
VULKAN_HPP_NAMESPACE::Device getDevice() const
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL
Sampler(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkSampler sampler, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
VULKAN_HPP_NAMESPACE::Semaphore const & operator*() const VULKAN_HPP_NOEXCEPT
VkDeviceSize(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
void(VKAPI_PTR * PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
void(VKAPI_PTR * PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:9993
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory)
Definition: vulkan_core.h:3930
PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV
PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
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)
LeafData & operator=(const LeafData &)=delete
void(VKAPI_PTR * PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange(T &obj, U &&newValue)
Definition: vulkan_raii.hpp:25
VkResult(VKAPI_PTR * PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:3997
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
Event(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkEvent event, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
void(VKAPI_PTR * PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
PerformanceConfigurationINTEL(PerformanceConfigurationINTEL &&rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
Definition: vulkan_core.h:9247
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result createInstance(const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks *pAllocator, VULKAN_HPP_NAMESPACE::Instance *pInstance, Dispatch const &d) VULKAN_HPP_NOEXCEPT
PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR
VkResult(VKAPI_PTR * PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
Definition: vulkan_core.h:3965
void(VKAPI_PTR * PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:7988
PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV
#define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
Definition: vulkan.hpp:5884
GLuint index
Definition: glcorearb.h:786
Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkFence fence, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties
void(VKAPI_PTR * PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
Definition: vulkan_core.h:3985
VkResult(VKAPI_PTR * PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
Definition: vulkan_core.h:8821
PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:8933
void(VKAPI_PTR * PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
Definition: vulkan_core.h:4031
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
Definition: vulkan_core.h:3908
void(VKAPI_PTR * PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
void(VKAPI_PTR * PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
VULKAN_HPP_NAMESPACE::Device getDevice() const
VkResult(VKAPI_PTR * PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
Definition: vulkan_core.h:7304
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
void(VKAPI_PTR * PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:8192
VULKAN_HPP_NAMESPACE::AccelerationStructureKHR release()
#define VK_HEADER_VERSION
Definition: vulkan_core.h:75
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
Definition: vulkan_core.h:3910
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
void(VKAPI_PTR * PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
VkResult(VKAPI_PTR * PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:4022
void(VKAPI_PTR * PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
Definition: vulkan_core.h:3923
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
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)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
void(VKAPI_PTR * PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
Definition: vulkan_core.h:7311
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:7299
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
Definition: vulkan_core.h:7318
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:3934
DebugUtilsMessengerEXT(DebugUtilsMessengerEXT &&rhs) VULKAN_HPP_NOEXCEPT
PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR
VkResult(VKAPI_PTR * PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
Definition: vulkan_core.h:7727
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
VkResult(VKAPI_PTR * PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_ios.h:33
void(VKAPI_PTR * PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pDecodeInfo)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VkResult(VKAPI_PTR * PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
Definition: vulkan_core.h:3946
PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR
VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
VkResult(VKAPI_PTR * PFN_vkCreateBufferCollectionFUCHSIA)(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferCollectionFUCHSIA *pCollection)
VkResult(VKAPI_PTR * PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:3922
PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR
PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR
IndirectCommandsLayoutNV(IndirectCommandsLayoutNV &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
Definition: vulkan_core.h:3911
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:8038
VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
void(VKAPI_PTR * PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo)
Definition: vulkan_beta.h:249
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
void(VKAPI_PTR * PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
Definition: vulkan_core.h:4033
PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:5545
VkResult(VKAPI_PTR * PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos)
Definition: vulkan_beta.h:245
PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate
ValidationCacheEXT(ValidationCacheEXT &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
void(VKAPI_PTR * PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3975
GLint GLsizei width
Definition: glcorearb.h:103
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT
VkResult(VKAPI_PTR * PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
Definition: vulkan_core.h:3982
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB *dfb)
VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
void(VKAPI_PTR * PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:9354
VkResult(VKAPI_PTR * PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
void(VKAPI_PTR * PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL &rhs) VULKAN_HPP_NOEXCEPT
Definition: core.h:982
VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
uint64_t VkDeviceSize
Definition: vulkan_core.h:95
PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV
VkResult(VKAPI_PTR * PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
Definition: vulkan_core.h:3974
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
void(VKAPI_PTR * PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
void(VKAPI_PTR * PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR
VkResult(VKAPI_PTR * PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
Definition: vulkan_core.h:8820
PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR
PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2
VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo)
void(VKAPI_PTR * PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
Definition: vulkan_core.h:4018
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)
PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV
void(VKAPI_PTR * PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
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)
VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
void(VKAPI_PTR * PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3942
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
Definition: vulkan_core.h:7728
VkResult(VKAPI_PTR * PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
Definition: vulkan_core.h:8238
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView &rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
VULKAN_HPP_NAMESPACE::ImageView const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
Definition: vulkan_core.h:7295
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT
VULKAN_HPP_NAMESPACE::PipelineCache const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:5546
void(VKAPI_PTR * PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3966
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
void(VKAPI_PTR * PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
Definition: vulkan_core.h:9893
void(VKAPI_PTR * PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
Definition: vulkan_core.h:8690
VkResult(VKAPI_PTR * PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV
void(VKAPI_PTR * PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
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)
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
Definition: vulkan_core.h:3980
VkResult(VKAPI_PTR * PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
Definition: vulkan_core.h:3998
VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator)
PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV
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)
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)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceExtensionProperties)(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:3919
VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
VkResult(VKAPI_PTR * PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:8237
VkResult(VKAPI_PTR * PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
Definition: vulkan_core.h:6384
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
Definition: vulkan_core.h:6378
BufferView(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkBufferView bufferView, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
VkResult(VKAPI_PTR * PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:3920
VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
void(VKAPI_PTR * PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements
uint32_t(VKAPI_PTR * PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
VkResult(VKAPI_PTR * PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
DeviceDispatcher(PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
VULKAN_HPP_NAMESPACE::ShaderModule const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo)
Definition: vulkan_beta.h:247
VkResult(VKAPI_PTR * PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
Definition: vulkan_core.h:3924
VkResult(VKAPI_PTR * PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
Definition: vulkan_core.h:9567
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR
void(VKAPI_PTR * PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3964
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties)
Definition: vulkan_beta.h:241
void(VKAPI_PTR * PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const VULKAN_HPP_NOEXCEPT
that also have some descendant prim *whose name begins with which in turn has a child named baz where *the predicate and *a name There is also one special expression reference
void(VKAPI_PTR * PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3949
SurfaceKHR(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, VkSurfaceKHR surface, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VULKAN_HPP_NAMESPACE::Pipeline const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
VkResult(VKAPI_PTR * PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
Definition: vulkan_core.h:3963
PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
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)
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:4021
PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR
VkFlags VkQueryResultFlags
Definition: vulkan_core.h:2461
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
Definition: vulkan_core.h:8758
void(VKAPI_PTR * PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:8463
type
Definition: core.h:1059
VULKAN_HPP_NAMESPACE::QueryPool const & operator*() const VULKAN_HPP_NOEXCEPT
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
Definition: vulkan_core.h:4017
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id)
VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements)
VkResult(VKAPI_PTR * PFN_vkGetBufferCollectionPropertiesFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA *pProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
Definition: vulkan_core.h:8333
VULKAN_HPP_NAMESPACE::Device getDevice() const
VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
void(VKAPI_PTR * PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
void(VKAPI_PTR * PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
VkResult(VKAPI_PTR * PFN_vkCreateScreenSurfaceQNX)(VkInstance instance, const VkScreenSurfaceCreateInfoQNX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_screen.h:34
VkResult(VKAPI_PTR * PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
Definition: vulkan_core.h:9151
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2
VULKAN_HPP_NAMESPACE::Device getDevice() const
VkResult(VKAPI_PTR * PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
Definition: vulkan_core.h:3986
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
Definition: vulkan_core.h:4011
VkResult(VKAPI_PTR * PFN_vkGetFenceStatus)(VkDevice device, VkFence fence)
Definition: vulkan_core.h:3944
void(VKAPI_PTR * PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule &rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR *pDisplay)
Definition: vulkan_win32.h:316
VkResult(VKAPI_PTR * PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, zx_handle_t *pZirconHandle)
uint64_t VkDeviceAddress
Definition: vulkan_core.h:94
void(VKAPI_PTR * PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VkResult(VKAPI_PTR * PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
Definition: vulkan_core.h:8561
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
void(VKAPI_PTR * PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:4030
Framebuffer(Framebuffer &&rhs) VULKAN_HPP_NOEXCEPT
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR
void(VKAPI_PTR * PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:4034
VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
Definition: vulkan_core.h:6382
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:5551
Instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const &context, VkInstance instance, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
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)
VkResult(VKAPI_PTR * PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VkRemoteAddressNV *pAddress)
VkResult(VKAPI_PTR * PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
Definition: vulkan_core.h:3976
VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV &rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay)
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
Definition: vulkan_core.h:4005
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
Definition: vulkan_core.h:8818
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:8981
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
GLuint64 GLenum GLint fd
Definition: RE_OGL.h:262
void(VKAPI_PTR * PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:7309
VkResult(VKAPI_PTR * PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:5547
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR
PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV
DebugReportCallbackEXT(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance, VkDebugReportCallbackEXT callback, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV
VULKAN_HPP_NAMESPACE::Instance const & operator*() const VULKAN_HPP_NOEXCEPT
VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo)
Definition: vulkan_win32.h:153
VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR *pDisplay)
PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
Definition: vulkan_core.h:7730
PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties
PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR
Definition: format.h:895
VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult(VKAPI_PTR * PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
Definition: vulkan_core.h:3960
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::Sampler const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3977
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)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:5544
PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties
auto join(It begin, Sentinel end, string_view sep) -> join_view< It, Sentinel >
Definition: format.h:2559
PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR
PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR
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)
PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2
uint64_t(VKAPI_PTR * PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
Definition: vulkan_core.h:6387
VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(VKAPI_PTR * PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
VkResult(VKAPI_PTR * PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
Definition: vulkan_core.h:7863
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
GLsizei const GLuint const GLintptr const GLsizei * strides
Definition: glcorearb.h:2625
PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion
VkResult(VKAPI_PTR * PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_win32.h:34
PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
void(VKAPI_PTR * PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
void(VKAPI_PTR * PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV release()
void(VKAPI_PTR * PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
Definition: vulkan_core.h:7320
Image(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkImage image, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties(uint32_t *pPropertyCount, VULKAN_HPP_NAMESPACE::LayerProperties *pProperties, Dispatch const &d) VULKAN_HPP_NOEXCEPT
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:8407
VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
VULKAN_HPP_NAMESPACE::Framebuffer const & operator*() const VULKAN_HPP_NOEXCEPT
PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT
VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
Definition: vulkan_core.h:9990
#define VULKAN_HPP_INLINE
Definition: vulkan.hpp:172
void(VKAPI_PTR * PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:4037
CuModuleNVX(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkCuModuleNVX module, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
void(VKAPI_PTR * PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:7314
InstanceDispatcher(PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance)
Definition: vulkan_raii.hpp:65
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1297
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
GLenum src
Definition: glcorearb.h:1793
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult(VKAPI_PTR * PFN_vkGetEventStatus)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3950
VkResult(VKAPI_PTR * PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
Definition: vulkan_core.h:9989
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)
void(VKAPI_PTR * PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
Definition: vulkan_win32.h:35
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:8158
CommandBuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkCommandBuffer commandBuffer, VkCommandPool commandPool)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VULKAN_HPP_NAMESPACE::Device const & operator*() const VULKAN_HPP_NOEXCEPT
PcpNodeRef_ChildrenIterator begin(const PcpNodeRef::child_const_range &r)
Support for range-based for loops for PcpNodeRef children ranges.
Definition: node.h:558