8 #ifndef VULKAN_RAII_HPP
9 #define VULKAN_RAII_HPP
15 #if !defined( VULKAN_HPP_RAII_NAMESPACE )
16 # define VULKAN_HPP_RAII_NAMESPACE raii
19 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) && !defined( VULKAN_HPP_NO_EXCEPTIONS )
24 template <
class T,
class U = T>
27 # if ( 14 <= VULKAN_HPP_CPP_VERSION )
28 return std::exchange<T>( obj, std::forward<U>( newValue ) );
30 T oldValue = std::move( obj );
31 obj = std::forward<U>( newValue );
115 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
138 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
149 # if defined( VK_USE_PLATFORM_WIN32_KHR )
158 # if defined( VK_USE_PLATFORM_METAL_EXT )
173 # if defined( VK_USE_PLATFORM_FUCHSIA )
178 # if defined( VK_USE_PLATFORM_GGP )
183 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
275 vkGetInstanceProcAddr( instance,
"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
290 # if defined( VK_ENABLE_BETA_EXTENSIONS )
298 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
305 # if defined( VK_USE_PLATFORM_WIN32_KHR )
312 # if defined( VK_USE_PLATFORM_XCB_KHR )
319 # if defined( VK_USE_PLATFORM_XLIB_KHR )
326 # if defined( VK_USE_PLATFORM_IOS_MVK )
331 # if defined( VK_USE_PLATFORM_MACOS_MVK )
336 # if defined( VK_USE_PLATFORM_VI_NN )
341 # if defined( VK_USE_PLATFORM_WIN32_KHR )
353 vkGetInstanceProcAddr( instance,
"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) );
363 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
409 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
434 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
446 # if defined( VK_USE_PLATFORM_WIN32_KHR )
456 # if defined( VK_USE_PLATFORM_METAL_EXT )
469 # if defined( VK_USE_PLATFORM_FUCHSIA )
476 # if defined( VK_USE_PLATFORM_GGP )
483 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
547 # if defined( VK_ENABLE_BETA_EXTENSIONS )
556 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
565 # if defined( VK_USE_PLATFORM_WIN32_KHR )
574 # if defined( VK_USE_PLATFORM_XCB_KHR )
583 # if defined( VK_USE_PLATFORM_XLIB_KHR )
592 # if defined( VK_USE_PLATFORM_IOS_MVK )
599 # if defined( VK_USE_PLATFORM_MACOS_MVK )
606 # if defined( VK_USE_PLATFORM_VI_NN )
613 # if defined( VK_USE_PLATFORM_WIN32_KHR )
634 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
864 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
922 vkGetDeviceProcAddr( device,
"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
1028 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1059 # if defined( VK_USE_PLATFORM_METAL_EXT )
1130 # if defined( VK_USE_PLATFORM_FUCHSIA )
1142 # if defined( VK_USE_PLATFORM_FUCHSIA )
1149 # if defined( VK_USE_PLATFORM_FUCHSIA )
1328 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1338 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1348 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1478 # if defined( VK_ENABLE_BETA_EXTENSIONS )
1483 # if defined( VK_ENABLE_BETA_EXTENSIONS )
1488 # if defined( VK_ENABLE_BETA_EXTENSIONS )
1537 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1807 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1928 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1959 # if defined( VK_USE_PLATFORM_METAL_EXT )
2022 # if defined( VK_USE_PLATFORM_FUCHSIA )
2037 # if defined( VK_USE_PLATFORM_FUCHSIA )
2046 # if defined( VK_USE_PLATFORM_FUCHSIA )
2154 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2167 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2180 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2264 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2271 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2278 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2336 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2443 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2445 class VideoSessionKHR;
2446 class VideoSessionParametersKHR;
2474 # if defined( VK_USE_PLATFORM_FUCHSIA )
2476 class BufferCollectionFUCHSIA;
2492 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2507 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2508 : m_dynamicLoader( std::move( rhs.m_dynamicLoader ) )
2509 , m_dispatcher( rhs.m_dispatcher.release() )
2511 : m_dispatcher( rhs.m_dispatcher.release() )
2520 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2521 m_dynamicLoader = std::move( rhs.m_dynamicLoader );
2523 m_dispatcher.reset( rhs.m_dispatcher.release() );
2531 return &*m_dispatcher;
2536 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2537 std::swap( m_dynamicLoader, rhs.m_dynamicLoader );
2539 m_dispatcher.swap( rhs.m_dispatcher );
2558 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2561 std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher> m_dispatcher;
2581 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
2582 reinterpret_cast<VkInstance *>( &m_instance ) ) );
2585 throwResultException( result,
"vkCreateInstance" );
2588 static_cast<VkInstance
>( m_instance ) ) );
2592 VkInstance instance,
2597 static_cast<VkInstance
>( m_instance ) ) );
2623 m_dispatcher.reset( rhs.m_dispatcher.release() );
2637 getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
2639 m_instance =
nullptr;
2640 m_allocator =
nullptr;
2641 m_dispatcher =
nullptr;
2646 m_allocator =
nullptr;
2647 m_dispatcher =
nullptr;
2654 return &*m_dispatcher;
2659 std::swap( m_instance, rhs.m_instance );
2660 std::swap( m_allocator, rhs.m_allocator );
2661 std::swap( m_dispatcher, rhs.m_dispatcher );
2666 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> enumeratePhysicalDevices()
const;
2672 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroups()
const;
2680 # if defined( VK_USE_PLATFORM_XLIB_KHR )
2684 createXlibSurfaceKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR
const & createInfo,
2688 # if defined( VK_USE_PLATFORM_XCB_KHR )
2692 createXcbSurfaceKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR
const & createInfo,
2696 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
2700 createWaylandSurfaceKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR
const & createInfo,
2704 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
2708 createAndroidSurfaceKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR
const & createInfo,
2712 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2716 createWin32SurfaceKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR
const & createInfo,
2730 int32_t messageCode,
2734 # if defined( VK_USE_PLATFORM_GGP )
2738 createStreamDescriptorSurfaceGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP
const & createInfo,
2742 # if defined( VK_USE_PLATFORM_VI_NN )
2746 createViSurfaceNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN
const & createInfo,
2752 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroupsKHR()
const;
2754 # if defined( VK_USE_PLATFORM_IOS_MVK )
2758 createIOSSurfaceMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK
const & createInfo,
2762 # if defined( VK_USE_PLATFORM_MACOS_MVK )
2766 createMacOSSurfaceMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK
const & createInfo,
2780 # if defined( VK_USE_PLATFORM_FUCHSIA )
2784 createImagePipeSurfaceFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA
const & createInfo,
2788 # if defined( VK_USE_PLATFORM_METAL_EXT )
2792 createMetalSurfaceEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT
const & createInfo,
2802 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
2806 createDirectFBSurfaceEXT( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT
const & createInfo,
2810 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
2814 createScreenSurfaceQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX
const & createInfo,
2821 std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher> m_dispatcher;
2835 : m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() )
2855 m_physicalDevice = rhs.m_physicalDevice;
2856 m_dispatcher = rhs.m_dispatcher;
2871 return m_physicalDevice;
2876 m_physicalDevice =
nullptr;
2877 m_dispatcher =
nullptr;
2882 m_dispatcher =
nullptr;
2889 return m_dispatcher;
2894 std::swap( m_physicalDevice, rhs.m_physicalDevice );
2895 std::swap( m_dispatcher, rhs.m_dispatcher );
2937 template <typename
X, typename
Y, typename...
Z>
2942 template <typename X, typename Y, typename...
Z>
2947 template <typename X, typename Y, typename...
Z>
2953 template <typename X, typename Y, typename...
Z>
2964 template <typename X, typename Y, typename...
Z>
3007 # if defined( VK_USE_PLATFORM_XLIB_KHR )
3011 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID )
const VULKAN_HPP_NOEXCEPT;
3014 # if defined( VK_USE_PLATFORM_XCB_KHR )
3018 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id )
const VULKAN_HPP_NOEXCEPT;
3021 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
3028 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3034 # if defined( VK_ENABLE_BETA_EXTENSIONS )
3038 getVideoCapabilitiesKHR(
const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile )
const;
3040 template <
typename X,
typename Y,
typename...
Z>
3044 getVideoFormatPropertiesKHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo )
const;
3061 template <typename X, typename Y, typename...
Z>
3066 template <typename X, typename Y, typename...
Z>
3071 template <typename X, typename Y, typename...
Z>
3077 template <typename X, typename Y, typename...
Z>
3088 template <typename X, typename Y, typename...
Z>
3104 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
3124 std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>>
3125 enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex )
const;
3135 template <
typename X,
typename Y,
typename...
Z>
3142 template <
typename StructureChain>
3147 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> getDisplayProperties2KHR()
const;
3149 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> getDisplayPlaneProperties2KHR()
const;
3161 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> getCalibrateableTimeDomainsEXT()
const;
3165 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> getFragmentShadingRatesKHR()
const;
3169 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> getToolPropertiesEXT()
const;
3173 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> getCooperativeMatrixPropertiesNV()
const;
3177 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> getSupportedFramebufferMixedSamplesCombinationsNV()
const;
3179 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3192 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3198 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
3205 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
3222 class PhysicalDevices :
public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice>
3228 std::vector<VkPhysicalDevice> physicalDevices;
3229 uint32_t physicalDeviceCount;
3237 physicalDevices.resize( physicalDeviceCount );
3239 dispatcher->
vkEnumeratePhysicalDevices( static_cast<VkInstance>( *instance ), &physicalDeviceCount, physicalDevices.data() ) );
3245 this->
reserve( physicalDeviceCount );
3246 for (
auto const & physicalDevice : physicalDevices )
3248 this->emplace_back( instance, physicalDevice );
3253 throwResultException( result,
"vkEnumeratePhysicalDevices" );
3283 reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
3284 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
3285 reinterpret_cast<VkDevice *>( &m_device ) ) );
3288 throwResultException( result,
"vkCreateDevice" );
3291 static_cast<VkDevice
>( m_device ) ) );
3300 static_cast<VkDevice
>( m_device ) ) );
3326 m_dispatcher.reset( rhs.m_dispatcher.release() );
3340 getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
3343 m_allocator =
nullptr;
3344 m_dispatcher =
nullptr;
3349 m_allocator =
nullptr;
3350 m_dispatcher =
nullptr;
3357 return &*m_dispatcher;
3363 std::swap( m_allocator, rhs.m_allocator );
3364 std::swap( m_dispatcher, rhs.m_dispatcher );
3373 void waitIdle()
const;
3494 getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex )
const VULKAN_HPP_NOEXCEPT;
3499 template <
typename X,
typename Y,
typename...
Z>
3506 template <
typename X,
typename Y,
typename...
Z>
3526 template <
typename X,
typename Y,
typename...
Z>
3555 uint64_t objectHandle,
3557 uint64_t
data )
const;
3560 uint64_t objectHandle,
3566 template <
typename X,
typename Y,
typename...
Z>
3573 template <
typename X,
typename Y,
typename...
Z>
3610 # if defined( VK_ENABLE_BETA_EXTENSIONS )
3614 createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR
const & createInfo,
3618 createVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR
const & createInfo,
3639 getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex )
const VULKAN_HPP_NOEXCEPT;
3641 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3644 VULKAN_HPP_NODISCARD HANDLE getMemoryWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo )
const;
3657 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3660 void importSemaphoreWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo )
const;
3662 VULKAN_HPP_NODISCARD HANDLE getSemaphoreWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo )
const;
3705 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3708 void importFenceWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo )
const;
3710 VULKAN_HPP_NODISCARD HANDLE getFenceWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo )
const;
3723 void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT;
3731 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
3735 getAndroidHardwareBufferPropertiesANDROID(
const struct AHardwareBuffer &
buffer )
const;
3737 template <
typename X,
typename Y,
typename...
Z>
3741 getMemoryAndroidHardwareBufferANDROID(
const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info )
const;
3749 template <
typename X,
typename Y,
typename...
Z>
3756 template <
typename X,
typename Y,
typename...
Z>
3786 template <
typename DataType>
3793 template <
typename DataType>
3841 template <
typename X,
typename Y,
typename...
Z>
3845 void bindAccelerationStructureMemoryNV(
3863 template <
typename X,
typename Y,
typename...
Z>
3890 void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT;
3903 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3933 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
3941 template <
typename X,
typename Y,
typename...
Z>
3960 uint64_t objectHandle,
3962 uint64_t
data )
const;
3965 uint64_t objectHandle,
3968 # if defined( VK_USE_PLATFORM_METAL_EXT )
3971 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT;
3973 template <typename X, typename Y, typename...
Z>
3979 template <
typename DescriptorType>
3982 template <
typename DataType>
3985 template <
typename DataType>
3988 template <
typename DataType>
3992 template <
typename DataType>
3995 template <
typename DataType>
4002 std::pair<VULKAN_HPP_NAMESPACE::Result, std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>
4003 getFaultInfoEXT()
const;
4007 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_RAII_NAMESPACE::Pipeline> createRayTracingPipelinesKHR(
4019 # if defined( VK_USE_PLATFORM_FUCHSIA )
4022 VULKAN_HPP_NODISCARD zx_handle_t getMemoryZirconHandleFUCHSIA(
const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo )
const;
4028 # if defined( VK_USE_PLATFORM_FUCHSIA )
4031 void importSemaphoreZirconHandleFUCHSIA(
const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo )
const;
4034 getSemaphoreZirconHandleFUCHSIA(
const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo )
const;
4037 # if defined( VK_USE_PLATFORM_FUCHSIA )
4041 createBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA
const & createInfo,
4073 template <
typename DataType>
4080 template <
typename DataType>
4097 template <
typename X,
typename Y,
typename...
Z>
4104 template <
typename X,
typename Y,
typename...
Z>
4135 std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher> m_dispatcher;
4141 using CType = VkAccelerationStructureKHR;
4151 : m_device( *device )
4153 , m_dispatcher( device.getDispatcher() )
4157 reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
4158 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4159 reinterpret_cast<VkAccelerationStructureKHR *>( &m_accelerationStructure ) ) );
4162 throwResultException( result,
"vkCreateAccelerationStructureKHR" );
4167 VkAccelerationStructureKHR accelerationStructure,
4169 : m_device( *device )
4170 , m_accelerationStructure( accelerationStructure )
4172 , m_dispatcher( device.getDispatcher() )
4208 return m_accelerationStructure;
4213 if ( m_accelerationStructure )
4215 getDispatcher()->vkDestroyAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
4216 static_cast<VkAccelerationStructureKHR>( m_accelerationStructure ),
4217 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4220 m_accelerationStructure =
nullptr;
4221 m_allocator =
nullptr;
4222 m_dispatcher =
nullptr;
4228 m_allocator =
nullptr;
4229 m_dispatcher =
nullptr;
4241 return m_dispatcher;
4247 std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
4248 std::swap( m_allocator, rhs.m_allocator );
4249 std::swap( m_dispatcher, rhs.m_dispatcher );
4262 using CType = VkAccelerationStructureNV;
4272 : m_device( *device )
4274 , m_dispatcher( device.getDispatcher() )
4278 reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
4279 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4280 reinterpret_cast<VkAccelerationStructureNV *>( &m_accelerationStructure ) ) );
4283 throwResultException( result,
"vkCreateAccelerationStructureNV" );
4288 VkAccelerationStructureNV accelerationStructure,
4290 : m_device( *device )
4291 , m_accelerationStructure( accelerationStructure )
4293 , m_dispatcher( device.getDispatcher() )
4329 return m_accelerationStructure;
4334 if ( m_accelerationStructure )
4336 getDispatcher()->vkDestroyAccelerationStructureNV( static_cast<VkDevice>( m_device ),
4337 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
4338 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4341 m_accelerationStructure =
nullptr;
4342 m_allocator =
nullptr;
4343 m_dispatcher =
nullptr;
4349 m_allocator =
nullptr;
4350 m_dispatcher =
nullptr;
4362 return m_dispatcher;
4368 std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
4369 std::swap( m_allocator, rhs.m_allocator );
4370 std::swap( m_dispatcher, rhs.m_dispatcher );
4375 template <
typename DataType>
4378 template <
typename DataType>
4401 : m_device( *device )
4403 , m_dispatcher( device.getDispatcher() )
4407 reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
4408 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4409 reinterpret_cast<VkBuffer *>( &m_buffer ) ) );
4412 throwResultException( result,
"vkCreateBuffer" );
4419 : m_device( *device )
4420 , m_buffer( buffer )
4422 , m_dispatcher( device.getDispatcher() )
4465 getDispatcher()->vkDestroyBuffer(
4466 static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( m_buffer ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4470 m_allocator =
nullptr;
4471 m_dispatcher =
nullptr;
4477 m_allocator =
nullptr;
4478 m_dispatcher =
nullptr;
4490 return m_dispatcher;
4497 std::swap( m_allocator, rhs.m_allocator );
4498 std::swap( m_dispatcher, rhs.m_dispatcher );
4514 # if defined( VK_USE_PLATFORM_FUCHSIA )
4515 class BufferCollectionFUCHSIA
4518 using CType = VkBufferCollectionFUCHSIA;
4522 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
4526 VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA
const & createInfo,
4528 : m_device( *device )
4530 , m_dispatcher( device.getDispatcher() )
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 ) ) );
4539 throwResultException( result,
"vkCreateBufferCollectionFUCHSIA" );
4544 VkBufferCollectionFUCHSIA collection,
4546 : m_device( *device )
4547 , m_collection( collection )
4549 , m_dispatcher( device.getDispatcher() )
4553 BufferCollectionFUCHSIA( std::nullptr_t ) {}
4555 ~BufferCollectionFUCHSIA()
4560 BufferCollectionFUCHSIA() =
delete;
4561 BufferCollectionFUCHSIA( BufferCollectionFUCHSIA
const & ) =
delete;
4569 BufferCollectionFUCHSIA &
operator=( BufferCollectionFUCHSIA
const & ) =
delete;
4583 VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA
const &
operator*() const VULKAN_HPP_NOEXCEPT
4585 return m_collection;
4588 void clear() VULKAN_HPP_NOEXCEPT
4592 getDispatcher()->vkDestroyBufferCollectionFUCHSIA( static_cast<VkDevice>( m_device ),
4593 static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
4594 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4597 m_collection =
nullptr;
4598 m_allocator =
nullptr;
4599 m_dispatcher =
nullptr;
4602 VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA release()
4605 m_allocator =
nullptr;
4606 m_dispatcher =
nullptr;
4618 return m_dispatcher;
4621 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA & rhs ) VULKAN_HPP_NOEXCEPT
4624 std::swap( m_collection, rhs.m_collection );
4625 std::swap( m_allocator, rhs.m_allocator );
4626 std::swap( m_dispatcher, rhs.m_dispatcher );
4631 void setImageConstraints(
const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo )
const;
4633 void setBufferConstraints(
const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo )
const;
4635 VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties()
const;
4639 VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_collection = {};
4658 : m_device( *device )
4660 , m_dispatcher( device.getDispatcher() )
4664 reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
4665 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4666 reinterpret_cast<VkBufferView *>( &m_bufferView ) ) );
4669 throwResultException( result,
"vkCreateBufferView" );
4674 VkBufferView bufferView,
4676 : m_device( *device )
4677 , m_bufferView( bufferView )
4679 , m_dispatcher( device.getDispatcher() )
4715 return m_bufferView;
4722 getDispatcher()->vkDestroyBufferView(
4723 static_cast<VkDevice>( m_device ), static_cast<VkBufferView>( m_bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4726 m_bufferView =
nullptr;
4727 m_allocator =
nullptr;
4728 m_dispatcher =
nullptr;
4734 m_allocator =
nullptr;
4735 m_dispatcher =
nullptr;
4747 return m_dispatcher;
4753 std::swap( m_bufferView, rhs.m_bufferView );
4754 std::swap( m_allocator, rhs.m_allocator );
4755 std::swap( m_dispatcher, rhs.m_dispatcher );
4778 : m_device( *device )
4780 , m_dispatcher( device.getDispatcher() )
4784 reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
4785 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
4786 reinterpret_cast<VkCommandPool *>( &m_commandPool ) ) );
4789 throwResultException( result,
"vkCreateCommandPool" );
4794 VkCommandPool commandPool,
4796 : m_device( *device )
4797 , m_commandPool( commandPool )
4799 , m_dispatcher( device.getDispatcher() )
4835 return m_commandPool;
4840 if ( m_commandPool )
4842 getDispatcher()->vkDestroyCommandPool(
4843 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4846 m_commandPool =
nullptr;
4847 m_allocator =
nullptr;
4848 m_dispatcher =
nullptr;
4854 m_allocator =
nullptr;
4855 m_dispatcher =
nullptr;
4867 return m_dispatcher;
4873 std::swap( m_commandPool, rhs.m_commandPool );
4874 std::swap( m_allocator, rhs.m_allocator );
4875 std::swap( m_dispatcher, rhs.m_dispatcher );
4908 : m_device( *device ), m_commandPool( commandPool ), m_commandBuffer( commandBuffer ), m_dispatcher( device.getDispatcher() )
4944 return m_commandBuffer;
4949 if ( m_commandBuffer )
4951 getDispatcher()->vkFreeCommandBuffers(
4952 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), 1, reinterpret_cast<VkCommandBuffer const *>( &m_commandBuffer ) );
4955 m_commandPool =
nullptr;
4956 m_commandBuffer =
nullptr;
4957 m_dispatcher =
nullptr;
4963 m_commandPool =
nullptr;
4964 m_dispatcher =
nullptr;
4976 return m_dispatcher;
4982 std::swap( m_commandPool, rhs.m_commandPool );
4983 std::swap( m_commandBuffer, rhs.m_commandBuffer );
4984 std::swap( m_dispatcher, rhs.m_dispatcher );
4997 void setViewport( uint32_t firstViewport,
5004 void setDepthBias(
float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor )
const VULKAN_HPP_NOEXCEPT;
5008 void setDepthBounds(
float minDepthBounds,
float maxDepthBounds )
const VULKAN_HPP_NOEXCEPT;
5026 void bindVertexBuffers( uint32_t firstBinding,
5030 void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance )
const VULKAN_HPP_NOEXCEPT;
5033 drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance )
const VULKAN_HPP_NOEXCEPT;
5045 void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ )
const VULKAN_HPP_NOEXCEPT;
5076 template <
typename DataType>
5140 uint32_t firstQuery,
5141 uint32_t queryCount,
5147 template <
typename ValuesType>
5158 void endRenderPass() const VULKAN_HPP_NOEXCEPT;
5164 void setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
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;
5175 uint32_t maxDrawCount,
5176 uint32_t
stride ) const VULKAN_HPP_NOEXCEPT;
5182 uint32_t maxDrawCount,
5183 uint32_t
stride ) const VULKAN_HPP_NOEXCEPT;
5222 void endRendering() const VULKAN_HPP_NOEXCEPT;
5234 void bindVertexBuffers2(
5235 uint32_t firstBinding,
5267 void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT;
5271 # if defined( VK_ENABLE_BETA_EXTENSIONS )
5274 void beginVideoCodingKHR(
const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo )
const VULKAN_HPP_NOEXCEPT;
5276 void endVideoCodingKHR(
const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo )
const VULKAN_HPP_NOEXCEPT;
5278 void controlVideoCodingKHR(
const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo )
const VULKAN_HPP_NOEXCEPT;
5281 # if defined( VK_ENABLE_BETA_EXTENSIONS )
5284 void decodeVideoKHR(
const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo )
const VULKAN_HPP_NOEXCEPT;
5289 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
5293 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT )
const;
5295 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
5298 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT )
const;
5300 void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
5303 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT )
const;
5312 void drawIndirectByteCountEXT( uint32_t instanceCount,
5313 uint32_t firstInstance,
5316 uint32_t counterOffset,
5329 uint32_t maxDrawCount,
5336 uint32_t maxDrawCount,
5343 void endRenderingKHR() const VULKAN_HPP_NOEXCEPT;
5347 void setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
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;
5358 VULKAN_HPP_NOEXCEPT;
5370 void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT;
5374 void setViewportWScalingNV( uint32_t firstViewport,
5376 VULKAN_HPP_NOEXCEPT;
5380 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
5397 void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT;
5407 void buildAccelerationStructuresKHR(
5411 void buildAccelerationStructuresIndirectKHR(
5423 void writeAccelerationStructuresPropertiesKHR(
5427 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT;
5433 void setViewportShadingRatePaletteNV(
5434 uint32_t firstViewport,
5439 VULKAN_HPP_NOEXCEPT;
5469 uint32_t
depth ) const VULKAN_HPP_NOEXCEPT;
5471 void writeAccelerationStructuresPropertiesNV(
5475 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT;
5483 uint32_t maxDrawCount,
5484 uint32_t
stride ) const VULKAN_HPP_NOEXCEPT;
5490 uint32_t maxDrawCount,
5491 uint32_t
stride ) const VULKAN_HPP_NOEXCEPT;
5498 uint32_t marker ) const VULKAN_HPP_NOEXCEPT;
5502 void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT;
5507 uint32_t
stride ) const VULKAN_HPP_NOEXCEPT;
5513 uint32_t maxDrawCount,
5514 uint32_t
stride ) const VULKAN_HPP_NOEXCEPT;
5518 void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
5523 template <typename CheckpointMarkerType>
5524 void setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT;
5541 void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT;
5555 void bindVertexBuffers2EXT(
5556 uint32_t firstBinding,
5587 uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT;
5589 # if defined( VK_ENABLE_BETA_EXTENSIONS )
5592 void encodeVideoKHR(
const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo )
const VULKAN_HPP_NOEXCEPT;
5638 void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ )
const VULKAN_HPP_NOEXCEPT;
5649 uint32_t maxDrawCount,
5682 void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize )
const VULKAN_HPP_NOEXCEPT;
5692 void subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT;
5700 void setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT;
5721 uint32_t instanceCount,
5722 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
5725 uint32_t instanceCount,
5726 uint32_t firstInstance,
5727 Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5742 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT;
5753 VULKAN_HPP_NOEXCEPT;
5758 VULKAN_HPP_NOEXCEPT;
5762 uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5783 void setColorBlendEnableEXT( uint32_t firstAttachment,
5786 void setColorBlendEquationEXT( uint32_t firstAttachment,
5788 VULKAN_HPP_NOEXCEPT;
5790 void setColorWriteMaskEXT( uint32_t firstAttachment,
5792 VULKAN_HPP_NOEXCEPT;
5794 void setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT;
5799 void setExtraPrimitiveOverestimationSizeEXT(
float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT;
5805 void setColorBlendAdvancedEXT( uint32_t firstAttachment,
5807 VULKAN_HPP_NOEXCEPT;
5819 void setViewportSwizzleNV( uint32_t firstViewport,
5821 VULKAN_HPP_NOEXCEPT;
5825 void setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT;
5829 void setCoverageModulationTableEnableNV(
VULKAN_HPP_NAMESPACE::
Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT;
5835 void setRepresentativeFragmentTestEnableNV(
VULKAN_HPP_NAMESPACE::
Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT;
5851 class CommandBuffers :
public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>
5860 static_cast<VkDevice>( *device ), reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ), commandBuffers.data() ) );
5864 for (
auto const & commandBuffer : commandBuffers )
5866 this->emplace_back( device, commandBuffer, static_cast<VkCommandPool>( allocateInfo.
commandPool ) );
5871 throwResultException( result,
"vkAllocateCommandBuffers" );
5897 : m_device( *device )
5899 , m_dispatcher( device.getDispatcher() )
5903 reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
5904 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
5905 reinterpret_cast<VkCuFunctionNVX *>( &m_function ) ) );
5908 throwResultException( result,
"vkCreateCuFunctionNVX" );
5913 VkCuFunctionNVX
function,
5915 : m_device( *device )
5916 , m_function( function )
5918 , m_dispatcher( device.getDispatcher() )
5961 getDispatcher()->vkDestroyCuFunctionNVX(
5962 static_cast<VkDevice>( m_device ), static_cast<VkCuFunctionNVX>( m_function ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
5965 m_function =
nullptr;
5966 m_allocator =
nullptr;
5967 m_dispatcher =
nullptr;
5973 m_allocator =
nullptr;
5974 m_dispatcher =
nullptr;
5986 return m_dispatcher;
5992 std::swap( m_function, rhs.m_function );
5993 std::swap( m_allocator, rhs.m_allocator );
5994 std::swap( m_dispatcher, rhs.m_dispatcher );
6017 : m_device( *device )
6019 , m_dispatcher( device.getDispatcher() )
6023 reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
6024 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6025 reinterpret_cast<VkCuModuleNVX *>( &m_module ) ) );
6028 throwResultException( result,
"vkCreateCuModuleNVX" );
6033 VkCuModuleNVX module,
6035 : m_device( *device )
6036 , m_module( module )
6038 , m_dispatcher( device.getDispatcher() )
6081 getDispatcher()->vkDestroyCuModuleNVX(
6082 static_cast<VkDevice>( m_device ), static_cast<VkCuModuleNVX>( m_module ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6086 m_allocator =
nullptr;
6087 m_dispatcher =
nullptr;
6093 m_allocator =
nullptr;
6094 m_dispatcher =
nullptr;
6106 return m_dispatcher;
6113 std::swap( m_allocator, rhs.m_allocator );
6114 std::swap( m_dispatcher, rhs.m_dispatcher );
6137 : m_instance( *instance )
6139 , m_dispatcher( instance.getDispatcher() )
6143 reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
6144 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6145 reinterpret_cast<VkDebugReportCallbackEXT *>( &m_callback ) ) );
6148 throwResultException( result,
"vkCreateDebugReportCallbackEXT" );
6153 VkDebugReportCallbackEXT callback,
6155 : m_instance( *instance )
6156 , m_callback( callback )
6158 , m_dispatcher( instance.getDispatcher() )
6201 getDispatcher()->vkDestroyDebugReportCallbackEXT( static_cast<VkInstance>( m_instance ),
6202 static_cast<VkDebugReportCallbackEXT>( m_callback ),
6203 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6205 m_instance =
nullptr;
6206 m_callback =
nullptr;
6207 m_allocator =
nullptr;
6208 m_dispatcher =
nullptr;
6213 m_instance =
nullptr;
6214 m_allocator =
nullptr;
6215 m_dispatcher =
nullptr;
6227 return m_dispatcher;
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 );
6258 : m_instance( *instance )
6260 , m_dispatcher( instance.getDispatcher() )
6264 reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
6265 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6266 reinterpret_cast<VkDebugUtilsMessengerEXT *>( &m_messenger ) ) );
6269 throwResultException( result,
"vkCreateDebugUtilsMessengerEXT" );
6274 VkDebugUtilsMessengerEXT messenger,
6276 : m_instance( *instance )
6277 , m_messenger( messenger )
6279 , m_dispatcher( instance.getDispatcher() )
6322 getDispatcher()->vkDestroyDebugUtilsMessengerEXT( static_cast<VkInstance>( m_instance ),
6323 static_cast<VkDebugUtilsMessengerEXT>( m_messenger ),
6324 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6326 m_instance =
nullptr;
6327 m_messenger =
nullptr;
6328 m_allocator =
nullptr;
6329 m_dispatcher =
nullptr;
6334 m_instance =
nullptr;
6335 m_allocator =
nullptr;
6336 m_dispatcher =
nullptr;
6348 return m_dispatcher;
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 );
6378 : m_device( *device )
6380 , m_dispatcher( device.getDispatcher() )
6384 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6385 reinterpret_cast<VkDeferredOperationKHR *>( &m_operation ) ) );
6388 throwResultException( result,
"vkCreateDeferredOperationKHR" );
6393 VkDeferredOperationKHR operation,
6395 : m_device( *device )
6396 , m_operation( operation )
6398 , m_dispatcher( device.getDispatcher() )
6441 getDispatcher()->vkDestroyDeferredOperationKHR( static_cast<VkDevice>( m_device ),
6442 static_cast<VkDeferredOperationKHR>( m_operation ),
6443 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6446 m_operation =
nullptr;
6447 m_allocator =
nullptr;
6448 m_dispatcher =
nullptr;
6454 m_allocator =
nullptr;
6455 m_dispatcher =
nullptr;
6467 return m_dispatcher;
6473 std::swap( m_operation, rhs.m_operation );
6474 std::swap( m_allocator, rhs.m_allocator );
6475 std::swap( m_dispatcher, rhs.m_dispatcher );
6506 : m_device( *device )
6508 , m_dispatcher( device.getDispatcher() )
6512 reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
6513 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6514 reinterpret_cast<VkDescriptorPool *>( &m_descriptorPool ) ) );
6517 throwResultException( result,
"vkCreateDescriptorPool" );
6522 VkDescriptorPool descriptorPool,
6524 : m_device( *device )
6525 , m_descriptorPool( descriptorPool )
6527 , m_dispatcher( device.getDispatcher() )
6563 return m_descriptorPool;
6568 if ( m_descriptorPool )
6570 getDispatcher()->vkDestroyDescriptorPool( static_cast<VkDevice>( m_device ),
6571 static_cast<VkDescriptorPool>( m_descriptorPool ),
6572 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6575 m_descriptorPool =
nullptr;
6576 m_allocator =
nullptr;
6577 m_dispatcher =
nullptr;
6583 m_allocator =
nullptr;
6584 m_dispatcher =
nullptr;
6596 return m_dispatcher;
6602 std::swap( m_descriptorPool, rhs.m_descriptorPool );
6603 std::swap( m_allocator, rhs.m_allocator );
6604 std::swap( m_dispatcher, rhs.m_dispatcher );
6629 : m_device( *device ), m_descriptorPool( descriptorPool ), m_descriptorSet( descriptorSet ), m_dispatcher( device.getDispatcher() )
6665 return m_descriptorSet;
6670 if ( m_descriptorSet )
6672 getDispatcher()->vkFreeDescriptorSets( static_cast<VkDevice>( m_device ),
6673 static_cast<VkDescriptorPool>( m_descriptorPool ),
6675 reinterpret_cast<VkDescriptorSet const *>( &m_descriptorSet ) );
6678 m_descriptorPool =
nullptr;
6679 m_descriptorSet =
nullptr;
6680 m_dispatcher =
nullptr;
6686 m_descriptorPool =
nullptr;
6687 m_dispatcher =
nullptr;
6699 return m_dispatcher;
6705 std::swap( m_descriptorPool, rhs.m_descriptorPool );
6706 std::swap( m_descriptorSet, rhs.m_descriptorSet );
6707 std::swap( m_dispatcher, rhs.m_dispatcher );
6712 template <
typename DataType>
6717 template <
typename DataType>
6731 class DescriptorSets :
public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>
6740 static_cast<VkDevice>( *device ), reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ), descriptorSets.data() ) );
6744 for (
auto const & descriptorSet : descriptorSets )
6746 this->emplace_back( device, descriptorSet, static_cast<VkDescriptorPool>( allocateInfo.
descriptorPool ) );
6751 throwResultException( result,
"vkAllocateDescriptorSets" );
6777 : m_device( *device )
6779 , m_dispatcher( device.getDispatcher() )
6783 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
6784 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6785 reinterpret_cast<VkDescriptorSetLayout *>( &m_descriptorSetLayout ) ) );
6788 throwResultException( result,
"vkCreateDescriptorSetLayout" );
6793 VkDescriptorSetLayout descriptorSetLayout,
6795 : m_device( *device )
6796 , m_descriptorSetLayout( descriptorSetLayout )
6798 , m_dispatcher( device.getDispatcher() )
6834 return m_descriptorSetLayout;
6839 if ( m_descriptorSetLayout )
6841 getDispatcher()->vkDestroyDescriptorSetLayout( static_cast<VkDevice>( m_device ),
6842 static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ),
6843 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6846 m_descriptorSetLayout =
nullptr;
6847 m_allocator =
nullptr;
6848 m_dispatcher =
nullptr;
6854 m_allocator =
nullptr;
6855 m_dispatcher =
nullptr;
6867 return m_dispatcher;
6873 std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout );
6874 std::swap( m_allocator, rhs.m_allocator );
6875 std::swap( m_dispatcher, rhs.m_dispatcher );
6894 using CType = VkDescriptorUpdateTemplate;
6904 : m_device( *device )
6906 , m_dispatcher( device.getDispatcher() )
6910 reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
6911 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
6912 reinterpret_cast<VkDescriptorUpdateTemplate *>( &m_descriptorUpdateTemplate ) ) );
6915 throwResultException( result,
"vkCreateDescriptorUpdateTemplate" );
6920 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
6922 : m_device( *device )
6923 , m_descriptorUpdateTemplate( descriptorUpdateTemplate )
6925 , m_dispatcher( device.getDispatcher() )
6961 return m_descriptorUpdateTemplate;
6966 if ( m_descriptorUpdateTemplate )
6968 getDispatcher()->vkDestroyDescriptorUpdateTemplate( static_cast<VkDevice>( m_device ),
6969 static_cast<VkDescriptorUpdateTemplate>( m_descriptorUpdateTemplate ),
6970 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6973 m_descriptorUpdateTemplate =
nullptr;
6974 m_allocator =
nullptr;
6975 m_dispatcher =
nullptr;
6981 m_allocator =
nullptr;
6982 m_dispatcher =
nullptr;
6994 return m_dispatcher;
7000 std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate );
7001 std::swap( m_allocator, rhs.m_allocator );
7002 std::swap( m_dispatcher, rhs.m_dispatcher );
7025 : m_device( *device )
7027 , m_dispatcher( device.getDispatcher() )
7031 reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
7032 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7033 reinterpret_cast<VkDeviceMemory *>( &m_memory ) ) );
7036 throwResultException( result,
"vkAllocateMemory" );
7043 : m_device( *device )
7044 , m_memory( memory )
7046 , m_dispatcher( device.getDispatcher() )
7089 getDispatcher()->vkFreeMemory(
7090 static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7094 m_allocator =
nullptr;
7095 m_dispatcher =
nullptr;
7101 m_allocator =
nullptr;
7102 m_dispatcher =
nullptr;
7114 return m_dispatcher;
7121 std::swap( m_allocator, rhs.m_allocator );
7122 std::swap( m_dispatcher, rhs.m_dispatcher );
7135 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7163 : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
7166 static_cast<VkPhysicalDevice>( *physicalDevice ), drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &m_display ) ) );
7169 throwResultException( result,
"vkGetDrmDisplayEXT" );
7173 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
7175 : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
7178 static_cast<VkPhysicalDevice>( *physicalDevice ), &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &m_display ) ) );
7181 throwResultException( result,
"vkGetRandROutputDisplayEXT" );
7186 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7188 : m_physicalDevice( *physicalDevice ), m_dispatcher( physicalDevice.getDispatcher() )
7191 static_cast<VkPhysicalDevice>( *physicalDevice ), deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &m_display ) ) );
7194 throwResultException( result,
"vkGetWinrtDisplayNV" );
7200 : m_physicalDevice( *physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() )
7241 getDispatcher()->vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) );
7243 m_physicalDevice =
nullptr;
7244 m_display =
nullptr;
7245 m_dispatcher =
nullptr;
7250 m_physicalDevice =
nullptr;
7251 m_dispatcher =
nullptr;
7257 return m_physicalDevice;
7263 return m_dispatcher;
7268 std::swap( m_physicalDevice, rhs.m_physicalDevice );
7270 std::swap( m_dispatcher, rhs.m_dispatcher );
7275 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties()
const;
7283 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2()
const;
7285 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7288 void acquireWinrtNV()
const;
7297 class DisplayKHRs :
public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>
7303 std::vector<VkDisplayKHR> displays;
7304 uint32_t displayCount;
7312 displays.resize( displayCount );
7314 static_cast<VkPhysicalDevice>( *physicalDevice ), planeIndex, &displayCount, displays.data() ) );
7320 this->
reserve( displayCount );
7321 for (
auto const & displayKHR : displays )
7323 this->emplace_back( physicalDevice, displayKHR );
7328 throwResultException( result,
"vkGetDisplayPlaneSupportedDisplaysKHR" );
7354 : m_physicalDevice( display.getPhysicalDevice() ), m_dispatcher( display.getDispatcher() )
7358 static_cast<VkDisplayKHR>( *display ),
7360 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
7361 reinterpret_cast<VkDisplayModeKHR *>( &m_displayModeKHR ) ) );
7364 throwResultException( result,
"vkCreateDisplayModeKHR" );
7369 : m_physicalDevice( display.getPhysicalDevice() ), m_displayModeKHR( displayModeKHR ), m_dispatcher( display.getDispatcher() )
7390 m_displayModeKHR = rhs.m_displayModeKHR;
7391 m_dispatcher = rhs.m_dispatcher;
7407 return m_displayModeKHR;
7412 m_physicalDevice =
nullptr;
7413 m_displayModeKHR =
nullptr;
7414 m_dispatcher =
nullptr;
7419 m_physicalDevice =
nullptr;
7420 m_dispatcher =
nullptr;
7427 return m_dispatcher;
7432 std::swap( m_physicalDevice, rhs.m_physicalDevice );
7433 std::swap( m_displayModeKHR, rhs.m_displayModeKHR );
7434 std::swap( m_dispatcher, rhs.m_dispatcher );
7460 : m_device( *device )
7462 , m_dispatcher( device.getDispatcher() )
7466 reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
7467 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7468 reinterpret_cast<VkEvent *>( &m_event ) ) );
7471 throwResultException( result,
"vkCreateEvent" );
7478 : m_device( *device )
7481 , m_dispatcher( device.getDispatcher() )
7524 getDispatcher()->vkDestroyEvent(
7525 static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7529 m_allocator =
nullptr;
7530 m_dispatcher =
nullptr;
7536 m_allocator =
nullptr;
7537 m_dispatcher =
nullptr;
7549 return m_dispatcher;
7556 std::swap( m_allocator, rhs.m_allocator );
7557 std::swap( m_dispatcher, rhs.m_dispatcher );
7588 : m_device( *device )
7590 , m_dispatcher( device.getDispatcher() )
7594 reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
7595 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7596 reinterpret_cast<VkFence *>( &m_fence ) ) );
7599 throwResultException( result,
"vkCreateFence" );
7606 : m_device( *device )
7608 , m_dispatcher( device.getDispatcher() )
7612 reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
7613 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7614 reinterpret_cast<VkFence *>( &m_fence ) ) );
7617 throwResultException( result,
"vkRegisterDeviceEventEXT" );
7625 : m_device( *device )
7627 , m_dispatcher( device.getDispatcher() )
7631 static_cast<VkDisplayKHR>( *display ),
7632 reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
7633 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7634 reinterpret_cast<VkFence *>( &m_fence ) ) );
7637 throwResultException( result,
"vkRegisterDisplayEventEXT" );
7644 : m_device( *device )
7647 , m_dispatcher( device.getDispatcher() )
7690 getDispatcher()->vkDestroyFence(
7691 static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7695 m_allocator =
nullptr;
7696 m_dispatcher =
nullptr;
7702 m_allocator =
nullptr;
7703 m_dispatcher =
nullptr;
7715 return m_dispatcher;
7722 std::swap( m_allocator, rhs.m_allocator );
7723 std::swap( m_dispatcher, rhs.m_dispatcher );
7750 : m_device( *device )
7752 , m_dispatcher( device.getDispatcher() )
7756 reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
7757 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7758 reinterpret_cast<VkFramebuffer *>( &m_framebuffer ) ) );
7761 throwResultException( result,
"vkCreateFramebuffer" );
7768 : m_device( *device )
7769 , m_framebuffer( framebuffer )
7771 , m_dispatcher( device.getDispatcher() )
7807 return m_framebuffer;
7812 if ( m_framebuffer )
7814 getDispatcher()->vkDestroyFramebuffer(
7815 static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( m_framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7818 m_framebuffer =
nullptr;
7819 m_allocator =
nullptr;
7820 m_dispatcher =
nullptr;
7826 m_allocator =
nullptr;
7827 m_dispatcher =
nullptr;
7839 return m_dispatcher;
7845 std::swap( m_framebuffer, rhs.m_framebuffer );
7846 std::swap( m_allocator, rhs.m_allocator );
7847 std::swap( m_dispatcher, rhs.m_dispatcher );
7852 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> getTilePropertiesQCOM()
const;
7874 : m_device( *device )
7876 , m_dispatcher( device.getDispatcher() )
7880 reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
7881 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
7882 reinterpret_cast<VkImage *>( &m_image ) ) );
7885 throwResultException( result,
"vkCreateImage" );
7892 : m_device( *device )
7895 , m_dispatcher( device.getDispatcher() )
7938 getDispatcher()->vkDestroyImage(
7939 static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7943 m_allocator =
nullptr;
7944 m_dispatcher =
nullptr;
7950 m_allocator =
nullptr;
7951 m_dispatcher =
nullptr;
7963 return m_dispatcher;
7970 std::swap( m_allocator, rhs.m_allocator );
7971 std::swap( m_dispatcher, rhs.m_dispatcher );
7994 template <typename
X, typename
Y, typename...
Z>
8018 : m_device( *device )
8020 , m_dispatcher( device.getDispatcher() )
8024 reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
8025 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8026 reinterpret_cast<VkImageView *>( &m_imageView ) ) );
8029 throwResultException( result,
"vkCreateImageView" );
8034 VkImageView imageView,
8036 : m_device( *device )
8037 , m_imageView( imageView )
8039 , m_dispatcher( device.getDispatcher() )
8082 getDispatcher()->vkDestroyImageView(
8083 static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8086 m_imageView =
nullptr;
8087 m_allocator =
nullptr;
8088 m_dispatcher =
nullptr;
8094 m_allocator =
nullptr;
8095 m_dispatcher =
nullptr;
8107 return m_dispatcher;
8113 std::swap( m_imageView, rhs.m_imageView );
8114 std::swap( m_allocator, rhs.m_allocator );
8115 std::swap( m_dispatcher, rhs.m_dispatcher );
8132 using CType = VkIndirectCommandsLayoutNV;
8142 : m_device( *device )
8144 , m_dispatcher( device.getDispatcher() )
8148 reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ),
8149 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8150 reinterpret_cast<VkIndirectCommandsLayoutNV *>( &m_indirectCommandsLayout ) ) );
8153 throwResultException( result,
"vkCreateIndirectCommandsLayoutNV" );
8158 VkIndirectCommandsLayoutNV indirectCommandsLayout,
8160 : m_device( *device )
8161 , m_indirectCommandsLayout( indirectCommandsLayout )
8163 , m_dispatcher( device.getDispatcher() )
8199 return m_indirectCommandsLayout;
8204 if ( m_indirectCommandsLayout )
8206 getDispatcher()->vkDestroyIndirectCommandsLayoutNV( static_cast<VkDevice>( m_device ),
8207 static_cast<VkIndirectCommandsLayoutNV>( m_indirectCommandsLayout ),
8208 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8211 m_indirectCommandsLayout =
nullptr;
8212 m_allocator =
nullptr;
8213 m_dispatcher =
nullptr;
8219 m_allocator =
nullptr;
8220 m_dispatcher =
nullptr;
8232 return m_dispatcher;
8238 std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout );
8239 std::swap( m_allocator, rhs.m_allocator );
8240 std::swap( m_dispatcher, rhs.m_dispatcher );
8263 : m_device( *device )
8265 , m_dispatcher( device.getDispatcher() )
8269 reinterpret_cast<const VkMicromapCreateInfoEXT *>( &createInfo ),
8270 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8271 reinterpret_cast<VkMicromapEXT *>( &m_micromap ) ) );
8274 throwResultException( result,
"vkCreateMicromapEXT" );
8279 VkMicromapEXT micromap,
8281 : m_device( *device )
8282 , m_micromap( micromap )
8284 , m_dispatcher( device.getDispatcher() )
8327 getDispatcher()->vkDestroyMicromapEXT(
8328 static_cast<VkDevice>( m_device ), static_cast<VkMicromapEXT>( m_micromap ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8331 m_micromap =
nullptr;
8332 m_allocator =
nullptr;
8333 m_dispatcher =
nullptr;
8339 m_allocator =
nullptr;
8340 m_dispatcher =
nullptr;
8352 return m_dispatcher;
8358 std::swap( m_micromap, rhs.m_micromap );
8359 std::swap( m_allocator, rhs.m_allocator );
8360 std::swap( m_dispatcher, rhs.m_dispatcher );
8383 : m_device( *device )
8385 , m_dispatcher( device.getDispatcher() )
8389 reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( &createInfo ),
8390 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8391 reinterpret_cast<VkOpticalFlowSessionNV *>( &m_session ) ) );
8394 throwResultException( result,
"vkCreateOpticalFlowSessionNV" );
8399 VkOpticalFlowSessionNV session,
8401 : m_device( *device )
8402 , m_session( session )
8404 , m_dispatcher( device.getDispatcher() )
8447 getDispatcher()->vkDestroyOpticalFlowSessionNV( static_cast<VkDevice>( m_device ),
8448 static_cast<VkOpticalFlowSessionNV>( m_session ),
8449 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8452 m_session =
nullptr;
8453 m_allocator =
nullptr;
8454 m_dispatcher =
nullptr;
8460 m_allocator =
nullptr;
8461 m_dispatcher =
nullptr;
8473 return m_dispatcher;
8480 std::swap( m_allocator, rhs.m_allocator );
8481 std::swap( m_dispatcher, rhs.m_dispatcher );
8500 using CType = VkPerformanceConfigurationINTEL;
8509 : m_device( *device ), m_dispatcher( device.getDispatcher() )
8513 reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
8514 reinterpret_cast<VkPerformanceConfigurationINTEL *>( &m_configuration ) ) );
8517 throwResultException( result,
"vkAcquirePerformanceConfigurationINTEL" );
8522 : m_device( *device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() )
8556 return m_configuration;
8561 if ( m_configuration )
8563 getDispatcher()->vkReleasePerformanceConfigurationINTEL( static_cast<VkDevice>( m_device ),
8564 static_cast<VkPerformanceConfigurationINTEL>( m_configuration ) );
8567 m_configuration =
nullptr;
8568 m_dispatcher =
nullptr;
8574 m_dispatcher =
nullptr;
8586 return m_dispatcher;
8592 std::swap( m_configuration, rhs.m_configuration );
8593 std::swap( m_dispatcher, rhs.m_dispatcher );
8615 : m_device( *device )
8617 , m_dispatcher( device.getDispatcher() )
8621 reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
8622 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8623 reinterpret_cast<VkPipelineCache *>( &m_pipelineCache ) ) );
8626 throwResultException( result,
"vkCreatePipelineCache" );
8631 VkPipelineCache pipelineCache,
8633 : m_device( *device )
8634 , m_pipelineCache( pipelineCache )
8636 , m_dispatcher( device.getDispatcher() )
8672 return m_pipelineCache;
8677 if ( m_pipelineCache )
8679 getDispatcher()->vkDestroyPipelineCache( static_cast<VkDevice>( m_device ),
8680 static_cast<VkPipelineCache>( m_pipelineCache ),
8681 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8684 m_pipelineCache =
nullptr;
8685 m_allocator =
nullptr;
8686 m_dispatcher =
nullptr;
8692 m_allocator =
nullptr;
8693 m_dispatcher =
nullptr;
8705 return m_dispatcher;
8711 std::swap( m_pipelineCache, rhs.m_pipelineCache );
8712 std::swap( m_allocator, rhs.m_allocator );
8713 std::swap( m_dispatcher, rhs.m_dispatcher );
8743 : m_device( *device )
8745 , m_dispatcher( device.getDispatcher() )
8748 getDispatcher()->vkCreateComputePipelines( static_cast<VkDevice>( *device ),
8749 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8751 reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ),
8752 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8753 reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
8757 throwResultException( m_constructorSuccessCode,
"vkCreateComputePipelines" );
8765 : m_device( *device )
8767 , m_dispatcher( device.getDispatcher() )
8770 getDispatcher()->vkCreateGraphicsPipelines( static_cast<VkDevice>( *device ),
8771 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8773 reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
8774 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8775 reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
8779 throwResultException( m_constructorSuccessCode,
"vkCreateGraphicsPipelines" );
8788 : m_device( *device )
8790 , m_dispatcher( device.getDispatcher() )
8793 getDispatcher()->vkCreateRayTracingPipelinesKHR( static_cast<VkDevice>( *device ),
8794 deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0,
8795 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8797 reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ),
8798 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8799 reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
8805 throwResultException( m_constructorSuccessCode,
"vkCreateRayTracingPipelinesKHR" );
8813 : m_device( *device )
8815 , m_dispatcher( device.getDispatcher() )
8818 getDispatcher()->vkCreateRayTracingPipelinesNV( static_cast<VkDevice>( *device ),
8819 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8821 reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
8822 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
8823 reinterpret_cast<VkPipeline *>( &m_pipeline ) ) );
8827 throwResultException( m_constructorSuccessCode,
"vkCreateRayTracingPipelinesNV" );
8832 VkPipeline pipeline,
8835 : m_device( *device )
8836 , m_pipeline( pipeline )
8838 , m_constructorSuccessCode( successCode )
8839 , m_dispatcher( device.getDispatcher() )
8884 getDispatcher()->vkDestroyPipeline(
8885 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8888 m_pipeline =
nullptr;
8889 m_allocator =
nullptr;
8891 m_dispatcher =
nullptr;
8897 m_allocator =
nullptr;
8899 m_dispatcher =
nullptr;
8905 return m_constructorSuccessCode;
8916 return m_dispatcher;
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 );
8935 template <
typename DataType>
8936 VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount,
size_t dataSize )
const;
8938 template <
typename DataType>
8941 void compileDeferredNV( uint32_t
shader )
const;
8945 template <
typename DataType>
8946 VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount,
size_t dataSize )
const;
8948 template <
typename DataType>
8951 template <
typename DataType>
8953 getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount,
size_t dataSize )
const;
8955 template <
typename DataType>
8969 class Pipelines :
public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>
8980 static_cast<VkDevice>( *device ),
8981 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
8984 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
8989 for (
auto const & pipeline :
pipelines )
8991 this->emplace_back( device, pipeline, allocator, result );
8996 throwResultException( result,
"vkCreateComputePipelines" );
9008 static_cast<VkDevice>( *device ),
9009 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
9012 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
9017 for (
auto const & pipeline :
pipelines )
9019 this->emplace_back( device, pipeline, allocator, result );
9024 throwResultException( result,
"vkCreateGraphicsPipelines" );
9037 static_cast<VkDevice>( *device ),
9038 deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0,
9039 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
9042 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
9048 for (
auto const & pipeline :
pipelines )
9050 this->emplace_back( device, pipeline, allocator, result );
9055 throwResultException( result,
"vkCreateRayTracingPipelinesKHR" );
9067 static_cast<VkDevice>( *device ),
9068 pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
9071 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
9076 for (
auto const & pipeline :
pipelines )
9078 this->emplace_back( device, pipeline, allocator, result );
9083 throwResultException( result,
"vkCreateRayTracingPipelinesNV" );
9109 : m_device( *device )
9111 , m_dispatcher( device.getDispatcher() )
9115 reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
9116 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9117 reinterpret_cast<VkPipelineLayout *>( &m_pipelineLayout ) ) );
9120 throwResultException( result,
"vkCreatePipelineLayout" );
9125 VkPipelineLayout pipelineLayout,
9127 : m_device( *device )
9128 , m_pipelineLayout( pipelineLayout )
9130 , m_dispatcher( device.getDispatcher() )
9166 return m_pipelineLayout;
9171 if ( m_pipelineLayout )
9173 getDispatcher()->vkDestroyPipelineLayout( static_cast<VkDevice>( m_device ),
9174 static_cast<VkPipelineLayout>( m_pipelineLayout ),
9175 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9178 m_pipelineLayout =
nullptr;
9179 m_allocator =
nullptr;
9180 m_dispatcher =
nullptr;
9186 m_allocator =
nullptr;
9187 m_dispatcher =
nullptr;
9199 return m_dispatcher;
9205 std::swap( m_pipelineLayout, rhs.m_pipelineLayout );
9206 std::swap( m_allocator, rhs.m_allocator );
9207 std::swap( m_dispatcher, rhs.m_dispatcher );
9230 : m_device( *device )
9232 , m_dispatcher( device.getDispatcher() )
9236 reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ),
9237 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9238 reinterpret_cast<VkPrivateDataSlot *>( &m_privateDataSlot ) ) );
9241 throwResultException( result,
"vkCreatePrivateDataSlot" );
9246 VkPrivateDataSlot privateDataSlot,
9248 : m_device( *device )
9249 , m_privateDataSlot( privateDataSlot )
9251 , m_dispatcher( device.getDispatcher() )
9287 return m_privateDataSlot;
9292 if ( m_privateDataSlot )
9294 getDispatcher()->vkDestroyPrivateDataSlot( static_cast<VkDevice>( m_device ),
9295 static_cast<VkPrivateDataSlot>( m_privateDataSlot ),
9296 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9299 m_privateDataSlot =
nullptr;
9300 m_allocator =
nullptr;
9301 m_dispatcher =
nullptr;
9307 m_allocator =
nullptr;
9308 m_dispatcher =
nullptr;
9320 return m_dispatcher;
9326 std::swap( m_privateDataSlot, rhs.m_privateDataSlot );
9327 std::swap( m_allocator, rhs.m_allocator );
9328 std::swap( m_dispatcher, rhs.m_dispatcher );
9351 : m_device( *device )
9353 , m_dispatcher( device.getDispatcher() )
9357 reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
9358 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9359 reinterpret_cast<VkQueryPool *>( &m_queryPool ) ) );
9362 throwResultException( result,
"vkCreateQueryPool" );
9367 VkQueryPool queryPool,
9369 : m_device( *device )
9370 , m_queryPool( queryPool )
9372 , m_dispatcher( device.getDispatcher() )
9415 getDispatcher()->vkDestroyQueryPool(
9416 static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9419 m_queryPool =
nullptr;
9420 m_allocator =
nullptr;
9421 m_dispatcher =
nullptr;
9427 m_allocator =
nullptr;
9428 m_dispatcher =
nullptr;
9440 return m_dispatcher;
9446 std::swap( m_queryPool, rhs.m_queryPool );
9447 std::swap( m_allocator, rhs.m_allocator );
9448 std::swap( m_dispatcher, rhs.m_dispatcher );
9453 template <
typename DataType>
9455 getResults( uint32_t firstQuery,
9456 uint32_t queryCount,
9461 template <
typename DataType>
9463 getResult( uint32_t firstQuery,
9464 uint32_t queryCount,
9494 : m_dispatcher( device.getDispatcher() )
9496 getDispatcher()->
vkGetDeviceQueue( static_cast<VkDevice>( *device ), queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &m_queue ) );
9500 : m_dispatcher( device.getDispatcher() )
9503 static_cast<VkDevice>( *device ), reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &m_queue ) );
9518 Queue(
Queue const & rhs ) : m_queue( rhs.m_queue ), m_dispatcher( rhs.m_dispatcher ) {}
9526 m_queue = rhs.m_queue;
9527 m_dispatcher = rhs.m_dispatcher;
9548 m_dispatcher =
nullptr;
9553 m_dispatcher =
nullptr;
9560 return m_dispatcher;
9566 std::swap( m_dispatcher, rhs.m_dispatcher );
9574 void waitIdle()
const;
9629 : m_device( *device )
9631 , m_dispatcher( device.getDispatcher() )
9635 reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
9636 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9637 reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
9640 throwResultException( result,
"vkCreateRenderPass" );
9647 : m_device( *device )
9649 , m_dispatcher( device.getDispatcher() )
9653 reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
9654 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9655 reinterpret_cast<VkRenderPass *>( &m_renderPass ) ) );
9658 throwResultException( result,
"vkCreateRenderPass2" );
9663 VkRenderPass renderPass,
9665 : m_device( *device )
9666 , m_renderPass( renderPass )
9668 , m_dispatcher( device.getDispatcher() )
9704 return m_renderPass;
9711 getDispatcher()->vkDestroyRenderPass(
9712 static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9715 m_renderPass =
nullptr;
9716 m_allocator =
nullptr;
9717 m_dispatcher =
nullptr;
9723 m_allocator =
nullptr;
9724 m_dispatcher =
nullptr;
9736 return m_dispatcher;
9742 std::swap( m_renderPass, rhs.m_renderPass );
9743 std::swap( m_allocator, rhs.m_allocator );
9744 std::swap( m_dispatcher, rhs.m_dispatcher );
9775 : m_device( *device )
9777 , m_dispatcher( device.getDispatcher() )
9781 reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
9782 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9783 reinterpret_cast<VkSampler *>( &m_sampler ) ) );
9786 throwResultException( result,
"vkCreateSampler" );
9793 : m_device( *device )
9794 , m_sampler( sampler )
9796 , m_dispatcher( device.getDispatcher() )
9839 getDispatcher()->vkDestroySampler(
9840 static_cast<VkDevice>( m_device ), static_cast<VkSampler>( m_sampler ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9843 m_sampler =
nullptr;
9844 m_allocator =
nullptr;
9845 m_dispatcher =
nullptr;
9851 m_allocator =
nullptr;
9852 m_dispatcher =
nullptr;
9864 return m_dispatcher;
9871 std::swap( m_allocator, rhs.m_allocator );
9872 std::swap( m_dispatcher, rhs.m_dispatcher );
9895 : m_device( *device )
9897 , m_dispatcher( device.getDispatcher() )
9901 reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
9902 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
9903 reinterpret_cast<VkSamplerYcbcrConversion *>( &m_ycbcrConversion ) ) );
9906 throwResultException( result,
"vkCreateSamplerYcbcrConversion" );
9911 VkSamplerYcbcrConversion ycbcrConversion,
9913 : m_device( *device )
9914 , m_ycbcrConversion( ycbcrConversion )
9916 , m_dispatcher( device.getDispatcher() )
9952 return m_ycbcrConversion;
9957 if ( m_ycbcrConversion )
9959 getDispatcher()->vkDestroySamplerYcbcrConversion( static_cast<VkDevice>( m_device ),
9960 static_cast<VkSamplerYcbcrConversion>( m_ycbcrConversion ),
9961 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9964 m_ycbcrConversion =
nullptr;
9965 m_allocator =
nullptr;
9966 m_dispatcher =
nullptr;
9972 m_allocator =
nullptr;
9973 m_dispatcher =
nullptr;
9985 return m_dispatcher;
9991 std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion );
9992 std::swap( m_allocator, rhs.m_allocator );
9993 std::swap( m_dispatcher, rhs.m_dispatcher );
10016 : m_device( *device )
10018 , m_dispatcher( device.getDispatcher() )
10022 reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
10023 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10024 reinterpret_cast<VkSemaphore *>( &m_semaphore ) ) );
10027 throwResultException( result,
"vkCreateSemaphore" );
10032 VkSemaphore semaphore,
10034 : m_device( *device )
10035 , m_semaphore( semaphore )
10037 , m_dispatcher( device.getDispatcher() )
10060 if (
this != &rhs )
10073 return m_semaphore;
10080 getDispatcher()->vkDestroySemaphore(
10081 static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10083 m_device =
nullptr;
10084 m_semaphore =
nullptr;
10085 m_allocator =
nullptr;
10086 m_dispatcher =
nullptr;
10091 m_device =
nullptr;
10092 m_allocator =
nullptr;
10093 m_dispatcher =
nullptr;
10105 return m_dispatcher;
10111 std::swap( m_semaphore, rhs.m_semaphore );
10112 std::swap( m_allocator, rhs.m_allocator );
10113 std::swap( m_dispatcher, rhs.m_dispatcher );
10144 : m_device( *device )
10146 , m_dispatcher( device.getDispatcher() )
10150 reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
10151 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10152 reinterpret_cast<VkShaderModule *>( &m_shaderModule ) ) );
10155 throwResultException( result,
"vkCreateShaderModule" );
10160 VkShaderModule shaderModule,
10162 : m_device( *device )
10163 , m_shaderModule( shaderModule )
10165 , m_dispatcher( device.getDispatcher() )
10188 if (
this != &rhs )
10201 return m_shaderModule;
10206 if ( m_shaderModule )
10208 getDispatcher()->vkDestroyShaderModule(
10209 static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( m_shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10211 m_device =
nullptr;
10212 m_shaderModule =
nullptr;
10213 m_allocator =
nullptr;
10214 m_dispatcher =
nullptr;
10219 m_device =
nullptr;
10220 m_allocator =
nullptr;
10221 m_dispatcher =
nullptr;
10233 return m_dispatcher;
10239 std::swap( m_shaderModule, rhs.m_shaderModule );
10240 std::swap( m_allocator, rhs.m_allocator );
10241 std::swap( m_dispatcher, rhs.m_dispatcher );
10265 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
10267 VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR
const & createInfo,
10269 : m_instance( *instance )
10271 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10280 throwResultException( result,
"vkCreateAndroidSurfaceKHR" );
10285 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
10287 VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT
const & createInfo,
10289 : m_instance( *instance )
10291 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10300 throwResultException( result,
"vkCreateDirectFBSurfaceEXT" );
10308 : m_instance( *instance )
10310 , m_dispatcher( instance.getDispatcher() )
10314 reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
10315 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10316 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10319 throwResultException( result,
"vkCreateDisplayPlaneSurfaceKHR" );
10326 : m_instance( *instance )
10328 , m_dispatcher( instance.getDispatcher() )
10332 reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
10333 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10334 reinterpret_cast<VkSurfaceKHR *>( &m_surface ) ) );
10337 throwResultException( result,
"vkCreateHeadlessSurfaceEXT" );
10341 # if defined( VK_USE_PLATFORM_IOS_MVK )
10343 VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK
const & createInfo,
10345 : m_instance( *instance )
10347 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10356 throwResultException( result,
"vkCreateIOSSurfaceMVK" );
10361 # if defined( VK_USE_PLATFORM_FUCHSIA )
10363 VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA
const & createInfo,
10365 : m_instance( *instance )
10367 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10376 throwResultException( result,
"vkCreateImagePipeSurfaceFUCHSIA" );
10381 # if defined( VK_USE_PLATFORM_MACOS_MVK )
10383 VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK
const & createInfo,
10385 : m_instance( *instance )
10387 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10396 throwResultException( result,
"vkCreateMacOSSurfaceMVK" );
10401 # if defined( VK_USE_PLATFORM_METAL_EXT )
10403 VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT
const & createInfo,
10405 : m_instance( *instance )
10407 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10416 throwResultException( result,
"vkCreateMetalSurfaceEXT" );
10421 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
10423 VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX
const & createInfo,
10425 : m_instance( *instance )
10427 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10436 throwResultException( result,
"vkCreateScreenSurfaceQNX" );
10441 # if defined( VK_USE_PLATFORM_GGP )
10443 VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP
const & createInfo,
10445 : m_instance( *instance )
10447 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10456 throwResultException( result,
"vkCreateStreamDescriptorSurfaceGGP" );
10461 # if defined( VK_USE_PLATFORM_VI_NN )
10463 VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN
const & createInfo,
10465 : m_instance( *instance )
10467 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10476 throwResultException( result,
"vkCreateViSurfaceNN" );
10481 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
10483 VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR
const & createInfo,
10485 : m_instance( *instance )
10487 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10496 throwResultException( result,
"vkCreateWaylandSurfaceKHR" );
10501 # if defined( VK_USE_PLATFORM_WIN32_KHR )
10503 VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR
const & createInfo,
10505 : m_instance( *instance )
10507 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10516 throwResultException( result,
"vkCreateWin32SurfaceKHR" );
10521 # if defined( VK_USE_PLATFORM_XCB_KHR )
10523 VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR
const & createInfo,
10525 : m_instance( *instance )
10527 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10536 throwResultException( result,
"vkCreateXcbSurfaceKHR" );
10541 # if defined( VK_USE_PLATFORM_XLIB_KHR )
10543 VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR
const & createInfo,
10545 : m_instance( *instance )
10547 , m_dispatcher( instance.getDispatcher() )
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 ) ) );
10556 throwResultException( result,
"vkCreateXlibSurfaceKHR" );
10564 : m_instance( *instance )
10565 , m_surface( surface )
10567 , m_dispatcher( instance.getDispatcher() )
10590 if (
this != &rhs )
10610 getDispatcher()->vkDestroySurfaceKHR(
10611 static_cast<VkInstance>( m_instance ), static_cast<VkSurfaceKHR>( m_surface ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10613 m_instance =
nullptr;
10614 m_surface =
nullptr;
10615 m_allocator =
nullptr;
10616 m_dispatcher =
nullptr;
10621 m_instance =
nullptr;
10622 m_allocator =
nullptr;
10623 m_dispatcher =
nullptr;
10635 return m_dispatcher;
10640 std::swap( m_instance, rhs.m_instance );
10642 std::swap( m_allocator, rhs.m_allocator );
10643 std::swap( m_dispatcher, rhs.m_dispatcher );
10666 : m_device( *device )
10668 , m_dispatcher( device.getDispatcher() )
10672 reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
10673 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10674 reinterpret_cast<VkSwapchainKHR *>( &m_swapchain ) ) );
10677 throwResultException( result,
"vkCreateSwapchainKHR" );
10682 VkSwapchainKHR swapchain,
10684 : m_device( *device )
10685 , m_swapchain( swapchain )
10687 , m_dispatcher( device.getDispatcher() )
10710 if (
this != &rhs )
10723 return m_swapchain;
10730 getDispatcher()->vkDestroySwapchainKHR(
10731 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10733 m_device =
nullptr;
10734 m_swapchain =
nullptr;
10735 m_allocator =
nullptr;
10736 m_dispatcher =
nullptr;
10741 m_device =
nullptr;
10742 m_allocator =
nullptr;
10743 m_dispatcher =
nullptr;
10755 return m_dispatcher;
10761 std::swap( m_swapchain, rhs.m_swapchain );
10762 std::swap( m_allocator, rhs.m_allocator );
10763 std::swap( m_dispatcher, rhs.m_dispatcher );
10771 acquireNextImage( uint64_t
timeout,
10783 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> getPastPresentationTimingGOOGLE()
const;
10797 # if defined( VK_USE_PLATFORM_WIN32_KHR )
10800 void acquireFullScreenExclusiveModeEXT()
const;
10802 void releaseFullScreenExclusiveModeEXT()
const;
10812 class SwapchainKHRs :
public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>
10820 std::vector<VkSwapchainKHR> swapchains( createInfos.
size() );
10822 static_cast<VkDevice>( *device ),
10823 createInfos.
size(),
10825 reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
10826 swapchains.data() ) );
10830 for (
auto const & swapchainKHR : swapchains )
10832 this->emplace_back( device, swapchainKHR, allocator );
10837 throwResultException( result,
"vkCreateSharedSwapchainsKHR" );
10863 : m_device( *device )
10865 , m_dispatcher( device.getDispatcher() )
10869 reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
10870 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ),
10871 reinterpret_cast<VkValidationCacheEXT *>( &m_validationCache ) ) );
10874 throwResultException( result,
"vkCreateValidationCacheEXT" );
10879 VkValidationCacheEXT validationCache,
10881 : m_device( *device )
10882 , m_validationCache( validationCache )
10884 , m_dispatcher( device.getDispatcher() )
10907 if (
this != &rhs )
10920 return m_validationCache;
10925 if ( m_validationCache )
10927 getDispatcher()->vkDestroyValidationCacheEXT( static_cast<VkDevice>( m_device ),
10928 static_cast<VkValidationCacheEXT>( m_validationCache ),
10929 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10931 m_device =
nullptr;
10932 m_validationCache =
nullptr;
10933 m_allocator =
nullptr;
10934 m_dispatcher =
nullptr;
10939 m_device =
nullptr;
10940 m_allocator =
nullptr;
10941 m_dispatcher =
nullptr;
10953 return m_dispatcher;
10959 std::swap( m_validationCache, rhs.m_validationCache );
10960 std::swap( m_allocator, rhs.m_allocator );
10961 std::swap( m_dispatcher, rhs.m_dispatcher );
10977 # if defined( VK_ENABLE_BETA_EXTENSIONS )
10978 class VideoSessionKHR
10981 using CType = VkVideoSessionKHR;
10989 VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR
const & createInfo,
10991 : m_device( *device )
10993 , m_dispatcher( device.getDispatcher() )
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 ) ) );
11002 throwResultException( result,
"vkCreateVideoSessionKHR" );
11007 VkVideoSessionKHR videoSession,
11009 : m_device( *device )
11010 , m_videoSession( videoSession )
11012 , m_dispatcher( device.getDispatcher() )
11016 VideoSessionKHR( std::nullptr_t ) {}
11023 VideoSessionKHR() =
delete;
11024 VideoSessionKHR( VideoSessionKHR
const & ) =
delete;
11032 VideoSessionKHR &
operator=( VideoSessionKHR
const & ) =
delete;
11035 if (
this != &rhs )
11046 VULKAN_HPP_NAMESPACE::VideoSessionKHR
const &
operator*() const VULKAN_HPP_NOEXCEPT
11048 return m_videoSession;
11051 void clear() VULKAN_HPP_NOEXCEPT
11053 if ( m_videoSession )
11055 getDispatcher()->vkDestroyVideoSessionKHR( static_cast<VkDevice>( m_device ),
11056 static_cast<VkVideoSessionKHR>( m_videoSession ),
11057 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
11059 m_device =
nullptr;
11060 m_videoSession =
nullptr;
11061 m_allocator =
nullptr;
11062 m_dispatcher =
nullptr;
11065 VULKAN_HPP_NAMESPACE::VideoSessionKHR release()
11067 m_device =
nullptr;
11068 m_allocator =
nullptr;
11069 m_dispatcher =
nullptr;
11081 return m_dispatcher;
11084 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR & rhs ) VULKAN_HPP_NOEXCEPT
11087 std::swap( m_videoSession, rhs.m_videoSession );
11088 std::swap( m_allocator, rhs.m_allocator );
11089 std::swap( m_dispatcher, rhs.m_dispatcher );
11094 VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> getMemoryRequirements()
const;
11100 VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSession = {};
11106 # if defined( VK_ENABLE_BETA_EXTENSIONS )
11107 class VideoSessionParametersKHR
11110 using CType = VkVideoSessionParametersKHR;
11118 VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR
const & createInfo,
11120 : m_device( *device )
11122 , m_dispatcher( device.getDispatcher() )
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 ) ) );
11131 throwResultException( result,
"vkCreateVideoSessionParametersKHR" );
11136 VkVideoSessionParametersKHR videoSessionParameters,
11138 : m_device( *device )
11139 , m_videoSessionParameters( videoSessionParameters )
11141 , m_dispatcher( device.getDispatcher() )
11145 VideoSessionParametersKHR( std::nullptr_t ) {}
11147 ~VideoSessionParametersKHR()
11152 VideoSessionParametersKHR() =
delete;
11153 VideoSessionParametersKHR( VideoSessionParametersKHR
const & ) =
delete;
11154 VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
11161 VideoSessionParametersKHR &
operator=( VideoSessionParametersKHR
const & ) =
delete;
11162 VideoSessionParametersKHR &
operator =( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT
11164 if (
this != &rhs )
11175 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR
const &
operator*() const VULKAN_HPP_NOEXCEPT
11177 return m_videoSessionParameters;
11180 void clear() VULKAN_HPP_NOEXCEPT
11182 if ( m_videoSessionParameters )
11184 getDispatcher()->vkDestroyVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
11185 static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ),
11186 reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
11188 m_device =
nullptr;
11189 m_videoSessionParameters =
nullptr;
11190 m_allocator =
nullptr;
11191 m_dispatcher =
nullptr;
11194 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR release()
11196 m_device =
nullptr;
11197 m_allocator =
nullptr;
11198 m_dispatcher =
nullptr;
11210 return m_dispatcher;
11213 void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR & rhs ) VULKAN_HPP_NOEXCEPT
11216 std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters );
11217 std::swap( m_allocator, rhs.m_allocator );
11218 std::swap( m_dispatcher, rhs.m_dispatcher );
11223 void update(
const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo )
const;
11227 VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParameters = {};
11254 getDispatcher()->vkGetPhysicalDeviceFeatures( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11255 reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) );
11264 getDispatcher()->vkGetPhysicalDeviceFormatProperties(
11265 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>(
format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) );
11267 return formatProperties;
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 ) );
11287 return imageFormatProperties;
11293 getDispatcher()->vkGetPhysicalDeviceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11294 reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) );
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() ) );
11310 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
11312 queueFamilyProperties.resize( queueFamilyPropertyCount );
11314 return queueFamilyProperties;
11320 getDispatcher()->vkGetPhysicalDeviceMemoryProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11321 reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) );
11323 return memoryProperties;
11328 PFN_vkVoidFunction result = getDispatcher()->vkGetInstanceProcAddr( static_cast<VkInstance>( m_instance ),
name.c_str() );
11335 PFN_vkVoidFunction result = getDispatcher()->vkGetDeviceProcAddr( static_cast<VkDevice>( m_device ),
name.c_str() );
11350 std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties;
11351 uint32_t propertyCount;
11355 result = getDispatcher()->vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() :
nullptr, &propertyCount, nullptr );
11356 if ( ( result ==
VK_SUCCESS ) && propertyCount )
11358 properties.resize( propertyCount );
11359 result = getDispatcher()->vkEnumerateInstanceExtensionProperties(
11360 layerName ? layerName->c_str() :
nullptr, &propertyCount,
reinterpret_cast<VkExtensionProperties *
>( properties.data() ) );
11365 if ( propertyCount < properties.size() )
11367 properties.resize( propertyCount );
11375 std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties;
11376 uint32_t propertyCount;
11380 result = getDispatcher()->vkEnumerateDeviceExtensionProperties(
11381 static_cast<VkPhysicalDevice>( m_physicalDevice ), layerName ? layerName->c_str() :
nullptr, &propertyCount, nullptr );
11382 if ( ( result ==
VK_SUCCESS ) && propertyCount )
11384 properties.resize( propertyCount );
11385 result = getDispatcher()->vkEnumerateDeviceExtensionProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11386 layerName ? layerName->c_str() :
nullptr,
11393 if ( propertyCount < properties.size() )
11395 properties.resize( propertyCount );
11402 std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties;
11403 uint32_t propertyCount;
11407 result = getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount,
nullptr );
11408 if ( ( result ==
VK_SUCCESS ) && propertyCount )
11410 properties.resize( propertyCount );
11411 result = getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) );
11416 if ( propertyCount < properties.size() )
11418 properties.resize( propertyCount );
11425 std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties;
11426 uint32_t propertyCount;
11430 result = getDispatcher()->vkEnumerateDeviceLayerProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount,
nullptr );
11431 if ( ( result ==
VK_SUCCESS ) && propertyCount )
11433 properties.resize( propertyCount );
11434 result = getDispatcher()->vkEnumerateDeviceLayerProperties(
11435 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) );
11440 if ( propertyCount < properties.size() )
11442 properties.resize( propertyCount );
11455 VkResult result = getDispatcher()->vkQueueSubmit(
11456 static_cast<VkQueue>( m_queue ), submits.
size(),
reinterpret_cast<const VkSubmitInfo *
>( submits.
data() ), static_cast<VkFence>( fence ) );
11462 VkResult result = getDispatcher()->vkQueueWaitIdle( static_cast<VkQueue>( m_queue ) );
11468 VkResult result = getDispatcher()->vkDeviceWaitIdle( static_cast<VkDevice>( m_device ) );
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 ),
11497 getDispatcher()->vkUnmapMemory( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ) );
11503 VkResult result = getDispatcher()->vkFlushMappedMemoryRanges(
11511 VkResult result = getDispatcher()->vkInvalidateMappedMemoryRanges(
11519 getDispatcher()->vkGetDeviceMemoryCommitment(
11520 static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
11522 return committedMemoryInBytes;
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 ) );
11536 VkResult result = getDispatcher()->vkBindImageMemory(
11537 static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), static_cast<VkDeviceMemory>( memory ), static_cast<VkDeviceSize>( memoryOffset ) );
11544 getDispatcher()->vkGetBufferMemoryRequirements(
11545 static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( m_buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
11547 return memoryRequirements;
11553 getDispatcher()->vkGetImageMemoryRequirements(
11554 static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
11556 return memoryRequirements;
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() ) );
11571 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
11572 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
11574 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
11576 return sparseMemoryRequirements;
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 ),
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 ),
11604 reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
11607 if ( propertyCount < properties.size() )
11609 properties.resize( propertyCount );
11617 VkResult result = getDispatcher()->vkQueueBindSparse(
11618 static_cast<VkQueue>( m_queue ), bindInfo.
size(),
reinterpret_cast<const VkBindSparseInfo *
>( bindInfo.
data() ), static_cast<VkFence>( fence ) );
11631 VkResult result = getDispatcher()->vkResetFences( static_cast<VkDevice>( m_device ), fences.
size(),
reinterpret_cast<const VkFence *
>( fences.
data() ) );
11637 VkResult result = getDispatcher()->vkGetFenceStatus( static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ) );
11638 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
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 ),
11673 VkResult result = getDispatcher()->vkGetEventStatus( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) );
11674 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
11683 VkResult result = getDispatcher()->vkSetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) );
11689 VkResult result = getDispatcher()->vkResetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) );
11700 template <
typename DataType>
11705 std::vector<DataType>
data( dataSize /
sizeof(
DataType ) );
11706 VkResult result = getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
11707 static_cast<VkQueryPool>( m_queryPool ),
11711 reinterpret_cast<void *>( data.data() ),
11712 static_cast<VkDeviceSize>( stride ),
11714 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
11718 return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data );
11721 template <
typename DataType>
11726 VkResult result = getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
11727 static_cast<VkQueryPool>( m_queryPool ),
11731 reinterpret_cast<void *>( &data ),
11732 static_cast<VkDeviceSize>( stride ),
11733 static_cast<VkQueryResultFlags>( flags ) );
11734 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
11738 return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data );
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 ) );
11797 std::vector<uint8_t>
data;
11803 getDispatcher()->vkGetPipelineCacheData( static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize,
nullptr );
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() ) );
11813 if ( dataSize < data.size() )
11815 data.resize( dataSize );
11822 VkResult result = getDispatcher()->vkMergePipelineCaches( static_cast<VkDevice>( m_device ),
11823 static_cast<VkPipelineCache>( m_pipelineCache ),
11825 reinterpret_cast<const VkPipelineCache *
>( srcCaches.
data() ) );
11891 getDispatcher()->vkResetDescriptorPool(
11892 static_cast<VkDevice>( m_device ), static_cast<VkDescriptorPool>( m_descriptorPool ), static_cast<VkDescriptorPoolResetFlags>(
flags ) );
11905 getDispatcher()->vkUpdateDescriptorSets( static_cast<VkDevice>( m_device ),
11906 descriptorWrites.size(),
11908 descriptorCopies.size(),
11929 getDispatcher()->vkGetRenderAreaGranularity(
11930 static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) );
11932 return granularity;
11944 VkResult result = getDispatcher()->vkResetCommandPool(
11945 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) );
11957 VkResult result = getDispatcher()->vkBeginCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
11958 reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) );
11964 VkResult result = getDispatcher()->vkEndCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ) );
11971 getDispatcher()->vkResetCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCommandBufferResetFlags>( flags ) );
11978 getDispatcher()->vkCmdBindPipeline(
11979 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
11983 CommandBuffer::setViewport( uint32_t firstViewport,
11986 getDispatcher()->vkCmdSetViewport(
11987 static_cast<VkCommandBuffer>( m_commandBuffer ), firstViewport, viewports.size(),
reinterpret_cast<const VkViewport *
>( viewports.data() ) );
11991 CommandBuffer::setScissor( uint32_t firstScissor,
11994 getDispatcher()->vkCmdSetScissor(
11995 static_cast<VkCommandBuffer>( m_commandBuffer ), firstScissor, scissors.size(),
reinterpret_cast<const VkRect2D *
>( scissors.data() ) );
12000 getDispatcher()->vkCmdSetLineWidth( static_cast<VkCommandBuffer>( m_commandBuffer ), lineWidth );
12004 CommandBuffer::setDepthBias(
float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor )
const VULKAN_HPP_NOEXCEPT
12006 getDispatcher()->vkCmdSetDepthBias( static_cast<VkCommandBuffer>( m_commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
12009 VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants(
const float blendConstants[4] )
const VULKAN_HPP_NOEXCEPT
12011 getDispatcher()->vkCmdSetBlendConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), blendConstants );
12014 VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds(
float minDepthBounds,
float maxDepthBounds )
const VULKAN_HPP_NOEXCEPT
12016 getDispatcher()->vkCmdSetDepthBounds( static_cast<VkCommandBuffer>( m_commandBuffer ), minDepthBounds, maxDepthBounds );
12020 uint32_t compareMask )
const VULKAN_HPP_NOEXCEPT
12022 getDispatcher()->vkCmdSetStencilCompareMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
12027 getDispatcher()->vkCmdSetStencilWriteMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
12032 getDispatcher()->vkCmdSetStencilReference( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ),
reference );
12042 getDispatcher()->vkCmdBindDescriptorSets( static_cast<VkCommandBuffer>( m_commandBuffer ),
12043 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
12044 static_cast<VkPipelineLayout>( layout ),
12046 descriptorSets.size(),
12047 reinterpret_cast<const VkDescriptorSet *
>( descriptorSets.data() ),
12048 dynamicOffsets.size(),
12049 dynamicOffsets.data() );
12056 getDispatcher()->vkCmdBindIndexBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12057 static_cast<VkBuffer>(
buffer ),
12058 static_cast<VkDeviceSize>(
offset ),
12059 static_cast<VkIndexType>( indexType ) );
12066 if ( buffers.
size() != offsets.
size() )
12071 getDispatcher()->vkCmdBindVertexBuffers( static_cast<VkCommandBuffer>( m_commandBuffer ),
12074 reinterpret_cast<const VkBuffer *
>( buffers.
data() ),
12075 reinterpret_cast<const VkDeviceSize *>( offsets.
data() ) );
12079 CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance )
const VULKAN_HPP_NOEXCEPT
12081 getDispatcher()->vkCmdDraw( static_cast<VkCommandBuffer>( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance );
12085 uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance )
const VULKAN_HPP_NOEXCEPT
12087 getDispatcher()->vkCmdDrawIndexed( static_cast<VkCommandBuffer>( m_commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
12092 uint32_t drawCount,
12093 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
12095 getDispatcher()->vkCmdDrawIndirect(
12096 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>(
buffer ), static_cast<VkDeviceSize>(
offset ), drawCount,
stride );
12101 uint32_t drawCount,
12102 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
12104 getDispatcher()->vkCmdDrawIndexedIndirect(
12105 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>(
buffer ), static_cast<VkDeviceSize>(
offset ), drawCount,
stride );
12108 VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ )
const VULKAN_HPP_NOEXCEPT
12110 getDispatcher()->vkCmdDispatch( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
12116 getDispatcher()->vkCmdDispatchIndirect(
12117 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>(
buffer ), static_cast<VkDeviceSize>(
offset ) );
12125 getDispatcher()->vkCmdCopyBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12126 static_cast<VkBuffer>( srcBuffer ),
12127 static_cast<VkBuffer>( dstBuffer ),
12129 reinterpret_cast<const VkBufferCopy *
>( regions.data() ) );
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 ),
12145 reinterpret_cast<const VkImageCopy *
>( regions.data() ) );
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 ),
12161 reinterpret_cast<const VkImageBlit *
>( regions.data() ),
12162 static_cast<VkFilter>(
filter ) );
12171 getDispatcher()->vkCmdCopyBufferToImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
12172 static_cast<VkBuffer>( srcBuffer ),
12173 static_cast<VkImage>( dstImage ),
12174 static_cast<VkImageLayout>( dstImageLayout ),
12185 getDispatcher()->vkCmdCopyImageToBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12186 static_cast<VkImage>( srcImage ),
12187 static_cast<VkImageLayout>( srcImageLayout ),
12188 static_cast<VkBuffer>( dstBuffer ),
12193 template <
typename DataType>
12198 getDispatcher()->vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12199 static_cast<VkBuffer>( dstBuffer ),
12200 static_cast<VkDeviceSize>( dstOffset ),
12202 reinterpret_cast<const void *>(
data.data() ) );
12208 uint32_t
data )
const VULKAN_HPP_NOEXCEPT
12210 getDispatcher()->vkCmdFillBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
12211 static_cast<VkBuffer>( dstBuffer ),
12212 static_cast<VkDeviceSize>( dstOffset ),
12213 static_cast<VkDeviceSize>(
size ),
12223 getDispatcher()->vkCmdClearColorImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
12224 static_cast<VkImage>(
image ),
12225 static_cast<VkImageLayout>( imageLayout ),
12226 reinterpret_cast<const VkClearColorValue *>( &
color ),
12237 getDispatcher()->vkCmdClearDepthStencilImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
12238 static_cast<VkImage>(
image ),
12239 static_cast<VkImageLayout>( imageLayout ),
12240 reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ),
12249 getDispatcher()->vkCmdClearAttachments( static_cast<VkCommandBuffer>( m_commandBuffer ),
12253 reinterpret_cast<const VkClearRect *
>( rects.data() ) );
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 ),
12275 getDispatcher()->vkCmdSetEvent(
12276 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>(
event ), static_cast<VkPipelineStageFlags>( stageMask ) );
12282 getDispatcher()->vkCmdResetEvent(
12283 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>(
event ), static_cast<VkPipelineStageFlags>( stageMask ) );
12294 getDispatcher()->vkCmdWaitEvents( static_cast<VkCommandBuffer>( m_commandBuffer ),
12296 reinterpret_cast<const VkEvent *
>( events.data() ),
12297 static_cast<VkPipelineStageFlags>( srcStageMask ),
12299 memoryBarriers.size(),
12301 bufferMemoryBarriers.size(),
12303 imageMemoryBarriers.
size(),
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(),
12321 bufferMemoryBarriers.size(),
12323 imageMemoryBarriers.
size(),
12331 getDispatcher()->vkCmdBeginQuery(
12332 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ),
query, static_cast<VkQueryControlFlags>(
flags ) );
12337 getDispatcher()->vkCmdEndQuery( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ),
query );
12343 getDispatcher()->vkCmdResetQueryPool( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
12348 uint32_t
query )
const VULKAN_HPP_NOEXCEPT
12350 getDispatcher()->vkCmdWriteTimestamp(
12351 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ),
query );
12355 uint32_t firstQuery,
12356 uint32_t queryCount,
12362 getDispatcher()->vkCmdCopyQueryPoolResults( static_cast<VkCommandBuffer>( m_commandBuffer ),
12363 static_cast<VkQueryPool>( queryPool ),
12366 static_cast<VkBuffer>( dstBuffer ),
12367 static_cast<VkDeviceSize>( dstOffset ),
12368 static_cast<VkDeviceSize>(
stride ),
12369 static_cast<VkQueryResultFlags>(
flags ) );
12372 template <
typename ValuesType>
12378 getDispatcher()->vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ),
12379 static_cast<VkPipelineLayout>( layout ),
12380 static_cast<VkShaderStageFlags>( stageFlags ),
12382 values.size() *
sizeof( ValuesType ),
12383 reinterpret_cast<const void *>(
values.data() ) );
12389 getDispatcher()->vkCmdBeginRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ),
12390 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
12391 static_cast<VkSubpassContents>( contents ) );
12396 getDispatcher()->vkCmdNextSubpass( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkSubpassContents>( contents ) );
12401 getDispatcher()->vkCmdEndRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ) );
12407 getDispatcher()->vkCmdExecuteCommands(
12408 static_cast<VkCommandBuffer>( m_commandBuffer ), commandBuffers.size(),
reinterpret_cast<const VkCommandBuffer *
>( commandBuffers.data() ) );
12415 uint32_t apiVersion;
12416 VkResult result = getDispatcher()->vkEnumerateInstanceVersion( &apiVersion );
12425 VkResult result = getDispatcher()->vkBindBufferMemory2(
12432 VkResult result = getDispatcher()->vkBindImageMemory2(
12438 Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex )
const VULKAN_HPP_NOEXCEPT
12441 getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures( static_cast<VkDevice>( m_device ),
12445 reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
12447 return peerMemoryFeatures;
12452 getDispatcher()->vkCmdSetDeviceMask( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
12456 uint32_t baseGroupY,
12457 uint32_t baseGroupZ,
12458 uint32_t groupCountX,
12459 uint32_t groupCountY,
12460 uint32_t groupCountZ )
const VULKAN_HPP_NOEXCEPT
12462 getDispatcher()->vkCmdDispatchBase(
12463 static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
12468 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
12469 uint32_t physicalDeviceGroupCount;
12473 result = getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount,
nullptr );
12474 if ( ( result ==
VK_SUCCESS ) && physicalDeviceGroupCount )
12476 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
12478 getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast<VkInstance>( m_instance ),
12479 &physicalDeviceGroupCount,
12480 reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) );
12484 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
12485 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
12487 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
12489 return physicalDeviceGroupProperties;
12496 getDispatcher()->vkGetImageMemoryRequirements2( static_cast<VkDevice>( m_device ),
12497 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
12498 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
12500 return memoryRequirements;
12503 template <
typename X,
typename Y,
typename...
Z>
12509 getDispatcher()->vkGetImageMemoryRequirements2( static_cast<VkDevice>( m_device ),
12510 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
12511 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
12513 return structureChain;
12520 getDispatcher()->vkGetBufferMemoryRequirements2( static_cast<VkDevice>( m_device ),
12521 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
12522 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
12524 return memoryRequirements;
12527 template <
typename X,
typename Y,
typename...
Z>
12533 getDispatcher()->vkGetBufferMemoryRequirements2( static_cast<VkDevice>( m_device ),
12534 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
12535 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
12537 return structureChain;
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() ) );
12553 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
12554 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
12556 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
12558 return sparseMemoryRequirements;
12564 getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12565 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
12570 template <
typename X,
typename Y,
typename...
Z>
12575 getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12576 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
12578 return structureChain;
12584 getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12585 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
12590 template <
typename X,
typename Y,
typename...
Z>
12595 getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12596 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
12598 return structureChain;
12605 getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
12606 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>(
format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
12608 return formatProperties;
12611 template <
typename X,
typename Y,
typename...
Z>
12617 getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
12618 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>(
format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
12620 return structureChain;
12628 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12629 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
12630 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
12633 return imageFormatProperties;
12636 template <
typename X,
typename Y,
typename...
Z>
12643 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12644 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
12645 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
12648 return structureChain;
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() ) );
12662 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
12664 queueFamilyProperties.resize( queueFamilyPropertyCount );
12666 return queueFamilyProperties;
12669 template <
typename StructureChain>
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++ )
12680 queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
12682 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12683 &queueFamilyPropertyCount,
12684 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
12687 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
12689 structureChains.resize( queueFamilyPropertyCount );
12691 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
12693 structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
12695 return structureChains;
12699 PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
12702 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12703 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
12705 return memoryProperties;
12708 template <
typename X,
typename Y,
typename...
Z>
12713 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
12714 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12715 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
12717 return structureChain;
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 ),
12729 properties.resize( propertyCount );
12730 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12731 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
12733 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
12736 if ( propertyCount < properties.size() )
12738 properties.resize( propertyCount );
12745 getDispatcher()->vkTrimCommandPool(
12746 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolTrimFlags>(
flags ) );
12768 template <
typename DataType>
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 ) );
12782 getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12783 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
12784 reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
12786 return externalBufferProperties;
12793 getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12794 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
12795 reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
12797 return externalFenceProperties;
12804 getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties(
12805 static_cast<VkPhysicalDevice>( m_physicalDevice ),
12806 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
12807 reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
12809 return externalSemaphoreProperties;
12816 getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast<VkDevice>( m_device ),
12817 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
12818 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
12823 template <
typename X,
typename Y,
typename...
Z>
12829 getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast<VkDevice>( m_device ),
12830 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
12831 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
12833 return structureChain;
12842 uint32_t maxDrawCount,
12843 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
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 ),
12858 uint32_t maxDrawCount,
12859 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
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 ),
12880 getDispatcher()->vkCmdBeginRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
12881 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
12882 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
12888 getDispatcher()->vkCmdNextSubpass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
12889 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
12890 reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
12895 getDispatcher()->vkCmdEndRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
12900 getDispatcher()->vkResetQueryPool( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
12906 VkResult result = getDispatcher()->vkGetSemaphoreCounterValue( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value );
12916 getDispatcher()->vkWaitSemaphores( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout );
12917 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
12926 VkResult result = getDispatcher()->vkSignalSemaphore( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) );
12934 getDispatcher()->vkGetBufferDeviceAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
12943 getDispatcher()->vkGetBufferOpaqueCaptureAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
12951 uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress( static_cast<VkDevice>( m_device ),
12952 reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
12961 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties;
12962 uint32_t toolCount;
12966 result = getDispatcher()->vkGetPhysicalDeviceToolProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount,
nullptr );
12967 if ( ( result ==
VK_SUCCESS ) && toolCount )
12969 toolProperties.resize( toolCount );
12970 result = getDispatcher()->vkGetPhysicalDeviceToolProperties(
12971 static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) );
12976 if ( toolCount < toolProperties.size() )
12978 toolProperties.resize( toolCount );
12980 return toolProperties;
12991 uint64_t objectHandle,
12993 uint64_t
data )
const
12995 VkResult result = getDispatcher()->vkSetPrivateData(
12996 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data );
13001 uint64_t objectHandle,
13005 getDispatcher()->vkGetPrivateData(
13006 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
13014 getDispatcher()->vkCmdSetEvent2(
13015 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>(
event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
13021 getDispatcher()->vkCmdResetEvent2(
13022 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>(
event ), static_cast<VkPipelineStageFlags2>( stageMask ) );
13029 if ( events.
size() != dependencyInfos.
size() )
13034 getDispatcher()->vkCmdWaitEvents2( static_cast<VkCommandBuffer>( m_commandBuffer ),
13036 reinterpret_cast<const VkEvent *
>( events.
data() ),
13037 reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.
data() ) );
13042 getDispatcher()->vkCmdPipelineBarrier2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
13047 uint32_t
query )
const VULKAN_HPP_NOEXCEPT
13049 getDispatcher()->vkCmdWriteTimestamp2(
13050 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ),
query );
13056 VkResult result = getDispatcher()->vkQueueSubmit2(
13057 static_cast<VkQueue>( m_queue ), submits.
size(),
reinterpret_cast<const VkSubmitInfo2 *
>( submits.
data() ), static_cast<VkFence>( fence ) );
13063 getDispatcher()->vkCmdCopyBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( ©BufferInfo ) );
13068 getDispatcher()->vkCmdCopyImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( ©ImageInfo ) );
13074 getDispatcher()->vkCmdCopyBufferToImage2( static_cast<VkCommandBuffer>( m_commandBuffer ),
13075 reinterpret_cast<const VkCopyBufferToImageInfo2 *>( ©BufferToImageInfo ) );
13081 getDispatcher()->vkCmdCopyImageToBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ),
13082 reinterpret_cast<const VkCopyImageToBufferInfo2 *>( ©ImageToBufferInfo ) );
13087 getDispatcher()->vkCmdBlitImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
13092 getDispatcher()->vkCmdResolveImage2( static_cast<VkCommandBuffer>( m_commandBuffer ),
13093 reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
13098 getDispatcher()->vkCmdBeginRendering( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
13103 getDispatcher()->vkCmdEndRendering( static_cast<VkCommandBuffer>( m_commandBuffer ) );
13108 getDispatcher()->vkCmdSetCullMode( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) );
13113 getDispatcher()->vkCmdSetFrontFace( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) );
13118 getDispatcher()->vkCmdSetPrimitiveTopology( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) );
13124 getDispatcher()->vkCmdSetViewportWithCount(
13125 static_cast<VkCommandBuffer>( m_commandBuffer ), viewports.size(),
reinterpret_cast<const VkViewport *
>( viewports.data() ) );
13131 getDispatcher()->vkCmdSetScissorWithCount(
13132 static_cast<VkCommandBuffer>( m_commandBuffer ), scissors.size(),
reinterpret_cast<const VkRect2D *
>( scissors.data() ) );
13135 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding,
13141 if ( buffers.
size() != offsets.
size() )
13149 if ( !strides.
empty() && buffers.
size() != strides.
size() )
13154 getDispatcher()->vkCmdBindVertexBuffers2( static_cast<VkCommandBuffer>( m_commandBuffer ),
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() ) );
13165 getDispatcher()->vkCmdSetDepthTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) );
13170 getDispatcher()->vkCmdSetDepthWriteEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) );
13175 getDispatcher()->vkCmdSetDepthCompareOp( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) );
13180 getDispatcher()->vkCmdSetDepthBoundsTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) );
13185 getDispatcher()->vkCmdSetStencilTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) );
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 ) );
13204 getDispatcher()->vkCmdSetRasterizerDiscardEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) );
13209 getDispatcher()->vkCmdSetDepthBiasEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) );
13214 getDispatcher()->vkCmdSetPrimitiveRestartEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) );
13221 getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
13222 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
13223 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13225 return memoryRequirements;
13228 template <
typename X,
typename Y,
typename...
Z>
13234 getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
13235 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
13236 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13238 return structureChain;
13245 getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast<VkDevice>( m_device ),
13246 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
13247 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13249 return memoryRequirements;
13252 template <
typename X,
typename Y,
typename...
Z>
13258 getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast<VkDevice>( m_device ),
13259 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
13260 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13262 return structureChain;
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() ) );
13278 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
13279 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
13281 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
13283 return sparseMemoryRequirements;
13292 "Function <vkGetPhysicalDeviceSurfaceSupportKHR> needs extension <VK_KHR_surface> enabled!" );
13295 VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR(
13296 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkBool32 *>( &supported ) );
13306 "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> needs extension <VK_KHR_surface> enabled!" );
13309 VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13310 static_cast<VkSurfaceKHR>( surface ),
13311 reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) );
13314 return surfaceCapabilities;
13321 "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> needs extension <VK_KHR_surface> enabled!" );
13323 std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> surfaceFormats;
13324 uint32_t surfaceFormatCount;
13328 result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR(
13329 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount,
nullptr );
13330 if ( ( result ==
VK_SUCCESS ) && surfaceFormatCount )
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() ) );
13341 if ( surfaceFormatCount < surfaceFormats.size() )
13343 surfaceFormats.resize( surfaceFormatCount );
13345 return surfaceFormats;
13352 "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> needs extension <VK_KHR_surface> enabled!" );
13354 std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
13355 uint32_t presentModeCount;
13359 result = getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR(
13360 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &presentModeCount,
nullptr );
13361 if ( ( result ==
VK_SUCCESS ) && presentModeCount )
13363 presentModes.resize( presentModeCount );
13364 result = getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13365 static_cast<VkSurfaceKHR>( surface ),
13367 reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) );
13372 if ( presentModeCount < presentModes.size() )
13374 presentModes.resize( presentModeCount );
13376 return presentModes;
13392 std::vector<VULKAN_HPP_NAMESPACE::Image> swapchainImages;
13393 uint32_t swapchainImageCount;
13397 result = getDispatcher()->vkGetSwapchainImagesKHR(
13398 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), &swapchainImageCount,
nullptr );
13399 if ( ( result ==
VK_SUCCESS ) && swapchainImageCount )
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() ) );
13410 if ( swapchainImageCount < swapchainImages.size() )
13412 swapchainImages.resize( swapchainImageCount );
13414 return swapchainImages;
13422 uint32_t imageIndex;
13423 VkResult result = getDispatcher()->vkAcquireNextImageKHR( static_cast<VkDevice>( m_device ),
13424 static_cast<VkSwapchainKHR>( m_swapchain ),
13426 static_cast<VkSemaphore>( semaphore ),
13427 static_cast<VkFence>( fence ),
13429 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
13436 return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex );
13443 VkResult result = getDispatcher()->vkQueuePresentKHR( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) );
13444 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
13454 "Function <vkGetDeviceGroupPresentCapabilitiesKHR> needs extension <VK_KHR_swapchain> enabled!" );
13457 VkResult result = getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR(
13458 static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) );
13461 return deviceGroupPresentCapabilities;
13468 "Function <vkGetDeviceGroupSurfacePresentModesKHR> needs extension <VK_KHR_swapchain> enabled!" );
13471 VkResult result = getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR(
13472 static_cast<VkDevice>( m_device ), static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) );
13482 "Function <vkGetPhysicalDevicePresentRectanglesKHR> needs extension <VK_KHR_swapchain> enabled!" );
13484 std::vector<VULKAN_HPP_NAMESPACE::Rect2D> rects;
13485 uint32_t rectCount;
13489 result = getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR(
13490 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &rectCount,
nullptr );
13491 if ( ( result ==
VK_SUCCESS ) && rectCount )
13493 rects.resize( rectCount );
13494 result = getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR(
13495 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D *>( rects.data() ) );
13500 if ( rectCount < rects.size() )
13502 rects.resize( rectCount );
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 ),
13522 return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex );
13530 "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> needs extension <VK_KHR_display> enabled!" );
13532 std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> properties;
13533 uint32_t propertyCount;
13537 result = getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount,
nullptr );
13538 if ( ( result ==
VK_SUCCESS ) && propertyCount )
13540 properties.resize( propertyCount );
13541 result = getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR(
13542 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) );
13547 if ( propertyCount < properties.size() )
13549 properties.resize( propertyCount );
13557 "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> needs extension <VK_KHR_display> enabled!" );
13559 std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> properties;
13560 uint32_t propertyCount;
13564 result = getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount,
nullptr );
13565 if ( ( result ==
VK_SUCCESS ) && propertyCount )
13567 properties.resize( propertyCount );
13568 result = getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
13569 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) );
13574 if ( propertyCount < properties.size() )
13576 properties.resize( propertyCount );
13582 PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex )
const
13590 "Function <vkGetDisplayModePropertiesKHR> needs extension <VK_KHR_display> enabled!" );
13592 std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> properties;
13593 uint32_t propertyCount;
13597 result = getDispatcher()->vkGetDisplayModePropertiesKHR(
13598 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ), &propertyCount,
nullptr );
13599 if ( ( result ==
VK_SUCCESS ) && propertyCount )
13601 properties.resize( propertyCount );
13602 result = getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13603 static_cast<VkDisplayKHR>( m_display ),
13605 reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) );
13610 if ( propertyCount < properties.size() )
13612 properties.resize( propertyCount );
13625 DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex )
const
13628 "Function <vkGetDisplayPlaneCapabilitiesKHR> needs extension <VK_KHR_display> enabled!" );
13631 VkResult result = getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13632 static_cast<VkDisplayModeKHR>( m_displayModeKHR ),
13634 reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) );
13637 return capabilities;
13663 # if defined( VK_USE_PLATFORM_XLIB_KHR )
13667 Instance::createXlibSurfaceKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR
const & createInfo,
13674 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID )
const VULKAN_HPP_NOEXCEPT
13677 "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> needs extension <VK_KHR_xlib_surface> enabled!" );
13680 getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dpy, visualID );
13686 # if defined( VK_USE_PLATFORM_XCB_KHR )
13690 Instance::createXcbSurfaceKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR
const & createInfo,
13693 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *
this, createInfo, allocator );
13697 uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id )
const VULKAN_HPP_NOEXCEPT
13700 "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> needs extension <VK_KHR_xcb_surface> enabled!" );
13702 VkBool32 result = getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR(
13703 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &connection, visual_id );
13709 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
13713 Instance::createWaylandSurfaceKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR
const & createInfo,
13716 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *
this, createInfo, allocator );
13720 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
struct wl_display & display )
const VULKAN_HPP_NOEXCEPT
13723 "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> needs extension <VK_KHR_wayland_surface> enabled!" );
13726 getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &display );
13732 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
13736 Instance::createAndroidSurfaceKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR
const & createInfo,
13739 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *
this, createInfo, allocator );
13743 # if defined( VK_USE_PLATFORM_WIN32_KHR )
13747 Instance::createWin32SurfaceKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR
const & createInfo,
13750 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *
this, createInfo, allocator );
13754 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex )
const VULKAN_HPP_NOEXCEPT
13757 "Function <vkGetPhysicalDeviceWin32PresentationSupportKHR> needs extension <VK_KHR_win32_surface> enabled!" );
13759 VkBool32 result = getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex );
13778 int32_t messageCode,
13784 getDispatcher()->vkDebugReportMessageEXT( static_cast<VkInstance>( m_instance ),
13785 static_cast<VkDebugReportFlagsEXT>(
flags ),
13786 static_cast<VkDebugReportObjectTypeEXT>( objectType_ ),
13790 layerPrefix.c_str(),
13799 "Function <vkDebugMarkerSetObjectTagEXT> needs extension <VK_EXT_debug_marker> enabled!" );
13802 getDispatcher()->vkDebugMarkerSetObjectTagEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) );
13809 "Function <vkDebugMarkerSetObjectNameEXT> needs extension <VK_EXT_debug_marker> enabled!" );
13811 VkResult result = getDispatcher()->vkDebugMarkerSetObjectNameEXT( static_cast<VkDevice>( m_device ),
13812 reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) );
13820 getDispatcher()->vkCmdDebugMarkerBeginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
13821 reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
13828 getDispatcher()->vkCmdDebugMarkerEndEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
13835 getDispatcher()->vkCmdDebugMarkerInsertEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
13836 reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
13839 # if defined( VK_ENABLE_BETA_EXTENSIONS )
13843 PhysicalDevice::getVideoCapabilitiesKHR(
const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile )
const
13846 "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
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 ) );
13854 return capabilities;
13857 template <
typename X,
typename Y,
typename...
Z>
13859 PhysicalDevice::getVideoCapabilitiesKHR(
const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile )
const
13862 "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
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 ) );
13871 return structureChain;
13875 PhysicalDevice::getVideoFormatPropertiesKHR(
const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo )
const
13878 "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> needs extension <VK_KHR_video_queue> enabled!" );
13880 std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> videoFormatProperties;
13881 uint32_t videoFormatPropertyCount;
13885 result = getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13886 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
13887 &videoFormatPropertyCount,
13889 if ( ( result ==
VK_SUCCESS ) && videoFormatPropertyCount )
13891 videoFormatProperties.resize( videoFormatPropertyCount );
13893 getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13894 reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
13895 &videoFormatPropertyCount,
13896 reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) );
13901 if ( videoFormatPropertyCount < videoFormatProperties.size() )
13903 videoFormatProperties.resize( videoFormatPropertyCount );
13905 return videoFormatProperties;
13909 Device::createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR
const & createInfo,
13912 return VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR( *
this, createInfo, allocator );
13918 "Function <vkGetVideoSessionMemoryRequirementsKHR> needs extension <VK_KHR_video_queue> enabled!" );
13920 std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> memoryRequirements;
13921 uint32_t memoryRequirementsCount;
13925 result = getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR(
13926 static_cast<VkDevice>( m_device ), static_cast<VkVideoSessionKHR>( m_videoSession ), &memoryRequirementsCount,
nullptr );
13927 if ( ( result ==
VK_SUCCESS ) && memoryRequirementsCount )
13929 memoryRequirements.resize( memoryRequirementsCount );
13931 getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
13932 static_cast<VkVideoSessionKHR>( m_videoSession ),
13933 &memoryRequirementsCount,
13934 reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) );
13939 if ( memoryRequirementsCount < memoryRequirements.size() )
13941 memoryRequirements.resize( memoryRequirementsCount );
13943 return memoryRequirements;
13950 "Function <vkBindVideoSessionMemoryKHR> needs extension <VK_KHR_video_queue> enabled!" );
13953 getDispatcher()->vkBindVideoSessionMemoryKHR( static_cast<VkDevice>( m_device ),
13954 static_cast<VkVideoSessionKHR>( m_videoSession ),
13955 bindSessionMemoryInfos.
size(),
13961 Device::createVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR
const & createInfo,
13964 return VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR( *
this, createInfo, allocator );
13967 VULKAN_HPP_INLINE void VideoSessionParametersKHR::update(
const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo )
const
13970 "Function <vkUpdateVideoSessionParametersKHR> needs extension <VK_KHR_video_queue> enabled!" );
13972 VkResult result = getDispatcher()->vkUpdateVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
13973 static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ),
13974 reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) );
13978 VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR(
const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo )
const VULKAN_HPP_NOEXCEPT
13982 getDispatcher()->vkCmdBeginVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
13983 reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) );
13986 VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR(
const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo )
const VULKAN_HPP_NOEXCEPT
13990 getDispatcher()->vkCmdEndVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
13991 reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) );
13995 CommandBuffer::controlVideoCodingKHR(
const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo )
const VULKAN_HPP_NOEXCEPT
13999 getDispatcher()->vkCmdControlVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
14000 reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) );
14004 # if defined( VK_ENABLE_BETA_EXTENSIONS )
14007 VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR(
const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo )
const VULKAN_HPP_NOEXCEPT
14011 getDispatcher()->vkCmdDecodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoDecodeInfoKHR *>( &decodeInfo ) );
14018 CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
14024 "Function <vkCmdBindTransformFeedbackBuffersEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14025 if ( buffers.
size() != offsets.
size() )
14027 throw LogicError(
VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
14031 throw LogicError(
VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
14034 getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
14037 reinterpret_cast<const VkBuffer *
>( buffers.
data() ),
14038 reinterpret_cast<const VkDeviceSize *>( offsets.
data() ),
14039 reinterpret_cast<const VkDeviceSize *>( sizes.
data() ) );
14043 CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
14048 "Function <vkCmdBeginTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14049 if ( !counterBufferOffsets.
empty() && counterBuffers.
size() != counterBufferOffsets.
size() )
14051 throw LogicError(
VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
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() ) );
14062 CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer,
14067 "Function <vkCmdEndTransformFeedbackEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14068 if ( !counterBufferOffsets.
empty() && counterBuffers.
size() != counterBufferOffsets.
size() )
14070 throw LogicError(
VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
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() ) );
14083 uint32_t
index )
const VULKAN_HPP_NOEXCEPT
14086 "Function <vkCmdBeginQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14088 getDispatcher()->vkCmdBeginQueryIndexedEXT(
14089 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ),
query, static_cast<VkQueryControlFlags>(
flags ),
index );
14096 "Function <vkCmdEndQueryIndexedEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14098 getDispatcher()->vkCmdEndQueryIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ),
query,
index );
14102 uint32_t firstInstance,
14105 uint32_t counterOffset,
14106 uint32_t vertexStride )
const VULKAN_HPP_NOEXCEPT
14109 "Function <vkCmdDrawIndirectByteCountEXT> needs extension <VK_EXT_transform_feedback> enabled!" );
14111 getDispatcher()->vkCmdDrawIndirectByteCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
14114 static_cast<VkBuffer>( counterBuffer ),
14115 static_cast<VkDeviceSize>( counterBufferOffset ),
14140 getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
14151 getDispatcher()->vkGetImageViewHandleNVX( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
14159 "Function <vkGetImageViewAddressNVX> needs extension <VK_NVX_image_view_handle> enabled!" );
14162 VkResult result = getDispatcher()->vkGetImageViewAddressNVX(
14163 static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) );
14175 uint32_t maxDrawCount,
14176 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
14179 "Function <vkCmdDrawIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" );
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 ),
14194 uint32_t maxDrawCount,
14195 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
14198 "Function <vkCmdDrawIndexedIndirectCountAMD> needs extension <VK_AMD_draw_indirect_count> enabled!" );
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 ),
14216 std::vector<uint8_t> info;
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 ),
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 ),
14235 reinterpret_cast<void *>( info.data() ) );
14240 if ( infoSize < info.size() )
14242 info.resize( infoSize );
14253 getDispatcher()->vkCmdBeginRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
14260 getDispatcher()->vkCmdEndRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ) );
14263 # if defined( VK_USE_PLATFORM_GGP )
14267 Instance::createStreamDescriptorSurfaceGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP
const & createInfo,
14285 "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> needs extension <VK_NV_external_memory_capabilities> enabled!" );
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 ) );
14299 return externalImageFormatProperties;
14302 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14308 "Function <vkGetMemoryWin32HandleNV> needs extension <VK_NV_external_memory_win32> enabled!" );
14311 VkResult result = getDispatcher()->vkGetMemoryWin32HandleNV(
14312 static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle );
14324 "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14327 getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14328 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
14333 template <
typename X,
typename Y,
typename...
Z>
14337 "Function <vkGetPhysicalDeviceFeatures2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14341 getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14342 reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
14344 return structureChain;
14350 "Function <vkGetPhysicalDeviceProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14353 getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14354 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
14359 template <
typename X,
typename Y,
typename...
Z>
14363 "Function <vkGetPhysicalDeviceProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14367 getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14368 reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
14370 return structureChain;
14377 "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14380 getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
14381 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>(
format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
14383 return formatProperties;
14386 template <
typename X,
typename Y,
typename...
Z>
14391 "Function <vkGetPhysicalDeviceFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14395 getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
14396 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>(
format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
14398 return structureChain;
14405 "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14409 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14410 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
14411 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
14414 return imageFormatProperties;
14417 template <
typename X,
typename Y,
typename...
Z>
14422 "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14427 getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14428 reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
14429 reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) );
14432 return structureChain;
14438 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
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() ) );
14449 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
14451 queueFamilyProperties.resize( queueFamilyPropertyCount );
14453 return queueFamilyProperties;
14456 template <
typename StructureChain>
14460 "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
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++ )
14470 queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
14472 getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14473 &queueFamilyPropertyCount,
14474 reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
14477 if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
14479 structureChains.resize( queueFamilyPropertyCount );
14481 for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
14483 structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
14485 return structureChains;
14489 PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
14492 "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14495 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14496 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
14498 return memoryProperties;
14501 template <
typename X,
typename Y,
typename...
Z>
14505 "Function <vkGetPhysicalDeviceMemoryProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
14509 structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
14510 getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14511 reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
14513 return structureChain;
14520 "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> needs extension <VK_KHR_get_physical_device_properties2> enabled!" );
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 ),
14528 properties.resize( propertyCount );
14529 getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14530 reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
14532 reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
14535 if ( propertyCount < properties.size() )
14537 properties.resize( propertyCount );
14545 Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex )
const VULKAN_HPP_NOEXCEPT
14548 "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> needs extension <VK_KHR_device_group> enabled!" );
14551 getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR( static_cast<VkDevice>( m_device ),
14555 reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
14557 return peerMemoryFeatures;
14564 getDispatcher()->vkCmdSetDeviceMaskKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
14568 uint32_t baseGroupY,
14569 uint32_t baseGroupZ,
14570 uint32_t groupCountX,
14571 uint32_t groupCountY,
14572 uint32_t groupCountZ )
const VULKAN_HPP_NOEXCEPT
14576 getDispatcher()->vkCmdDispatchBaseKHR(
14577 static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
14580 # if defined( VK_USE_PLATFORM_VI_NN )
14584 Instance::createViSurfaceNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN
const & createInfo,
14597 getDispatcher()->vkTrimCommandPoolKHR(
14598 static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolTrimFlags>(
flags ) );
14606 "Function <vkEnumeratePhysicalDeviceGroupsKHR> needs extension <VK_KHR_device_group_creation> enabled!" );
14608 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
14609 uint32_t physicalDeviceGroupCount;
14613 result = getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount,
nullptr );
14614 if ( ( result ==
VK_SUCCESS ) && physicalDeviceGroupCount )
14616 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
14618 getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( static_cast<VkInstance>( m_instance ),
14619 &physicalDeviceGroupCount,
14620 reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) );
14624 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
14625 if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
14627 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
14629 return physicalDeviceGroupProperties;
14638 "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> needs extension <VK_KHR_external_memory_capabilities> enabled!" );
14641 getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14642 reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
14643 reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
14645 return externalBufferProperties;
14648 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14652 Device::getMemoryWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo )
const
14655 "Function <vkGetMemoryWin32HandleKHR> needs extension <VK_KHR_external_memory_win32> enabled!" );
14658 VkResult result = getDispatcher()->vkGetMemoryWin32HandleKHR(
14659 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle );
14669 "Function <vkGetMemoryWin32HandlePropertiesKHR> needs extension <VK_KHR_external_memory_win32> enabled!" );
14671 VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
14673 getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR( static_cast<VkDevice>( m_device ),
14674 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
14676 reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) );
14679 return memoryWin32HandleProperties;
14691 getDispatcher()->vkGetMemoryFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd );
14701 "Function <vkGetMemoryFdPropertiesKHR> needs extension <VK_KHR_external_memory_fd> enabled!" );
14704 VkResult result = getDispatcher()->vkGetMemoryFdPropertiesKHR( static_cast<VkDevice>( m_device ),
14705 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
14707 reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) );
14710 return memoryFdProperties;
14719 "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> needs extension <VK_KHR_external_semaphore_capabilities> enabled!" );
14722 getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
14723 static_cast<VkPhysicalDevice>( m_physicalDevice ),
14724 reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
14725 reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
14727 return externalSemaphoreProperties;
14730 # if defined( VK_USE_PLATFORM_WIN32_KHR )
14734 Device::importSemaphoreWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo )
const
14737 "Function <vkImportSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" );
14739 VkResult result = getDispatcher()->vkImportSemaphoreWin32HandleKHR(
14740 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) );
14745 Device::getSemaphoreWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo )
const
14748 "Function <vkGetSemaphoreWin32HandleKHR> needs extension <VK_KHR_external_semaphore_win32> enabled!" );
14751 VkResult result = getDispatcher()->vkGetSemaphoreWin32HandleKHR(
14752 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle );
14764 "Function <vkImportSemaphoreFdKHR> needs extension <VK_KHR_external_semaphore_fd> enabled!" );
14766 VkResult result = getDispatcher()->vkImportSemaphoreFdKHR( static_cast<VkDevice>( m_device ),
14767 reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) );
14777 getDispatcher()->vkGetSemaphoreFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd );
14792 "Function <vkCmdPushDescriptorSetKHR> needs extension <VK_KHR_push_descriptor> enabled!" );
14794 getDispatcher()->vkCmdPushDescriptorSetKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
14795 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
14796 static_cast<VkPipelineLayout>( layout ),
14798 descriptorWrites.size(),
14802 template <
typename DataType>
14809 "Function <vkCmdPushDescriptorSetWithTemplateKHR> needs extension <VK_KHR_push_descriptor> enabled!" );
14811 getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
14812 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
14813 static_cast<VkPipelineLayout>( layout ),
14815 reinterpret_cast<const void *>( &
data ) );
14824 "Function <vkCmdBeginConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" );
14826 getDispatcher()->vkCmdBeginConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
14827 reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) );
14833 "Function <vkCmdEndConditionalRenderingEXT> needs extension <VK_EXT_conditional_rendering> enabled!" );
14835 getDispatcher()->vkCmdEndConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
14852 "Function <vkDestroyDescriptorUpdateTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" );
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 ) ) );
14860 template <
typename DataType>
14865 "Function <vkUpdateDescriptorSetWithTemplateKHR> needs extension <VK_KHR_descriptor_update_template> enabled!" );
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 ) );
14876 uint32_t firstViewport,
14880 "Function <vkCmdSetViewportWScalingNV> needs extension <VK_NV_clip_space_w_scaling> enabled!" );
14882 getDispatcher()->vkCmdSetViewportWScalingNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
14884 viewportWScalings.size(),
14888 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
14894 "Function <vkAcquireXlibDisplayEXT> needs extension <VK_EXT_acquire_xlib_display> enabled!" );
14897 getDispatcher()->vkAcquireXlibDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &dpy, static_cast<VkDisplayKHR>( display ) );
14902 RROutput rrOutput )
const
14914 "Function <vkGetPhysicalDeviceSurfaceCapabilities2EXT> needs extension <VK_EXT_display_surface_counter> enabled!" );
14917 VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14918 static_cast<VkSurfaceKHR>( surface ),
14919 reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) );
14922 return surfaceCapabilities;
14932 VkResult result = getDispatcher()->vkDisplayPowerControlEXT(
14933 static_cast<VkDevice>( m_device ), static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) );
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 );
14961 return counterValue;
14969 "Function <vkGetRefreshCycleDurationGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" );
14972 VkResult result = getDispatcher()->vkGetRefreshCycleDurationGOOGLE( static_cast<VkDevice>( m_device ),
14973 static_cast<VkSwapchainKHR>( m_swapchain ),
14974 reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) );
14977 return displayTimingProperties;
14983 "Function <vkGetPastPresentationTimingGOOGLE> needs extension <VK_GOOGLE_display_timing> enabled!" );
14985 std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> presentationTimings;
14986 uint32_t presentationTimingCount;
14990 result = getDispatcher()->vkGetPastPresentationTimingGOOGLE(
14991 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), &presentationTimingCount,
nullptr );
14992 if ( ( result ==
VK_SUCCESS ) && presentationTimingCount )
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() ) );
15003 if ( presentationTimingCount < presentationTimings.size() )
15005 presentationTimings.resize( presentationTimingCount );
15007 return presentationTimings;
15016 "Function <vkCmdSetDiscardRectangleEXT> needs extension <VK_EXT_discard_rectangles> enabled!" );
15018 getDispatcher()->vkCmdSetDiscardRectangleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15019 firstDiscardRectangle,
15020 discardRectangles.size(),
15021 reinterpret_cast<const VkRect2D *
>( discardRectangles.data() ) );
15030 if ( swapchains.
size() != metadata.
size() )
15035 getDispatcher()->vkSetHdrMetadataEXT( static_cast<VkDevice>( m_device ),
15037 reinterpret_cast<const VkSwapchainKHR *
>( swapchains.
data() ),
15038 reinterpret_cast<const VkHdrMetadataEXT *>( metadata.
data() ) );
15054 "Function <vkCmdBeginRenderPass2KHR> needs extension <VK_KHR_create_renderpass2> enabled!" );
15056 getDispatcher()->vkCmdBeginRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15057 reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
15058 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
15066 getDispatcher()->vkCmdNextSubpass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15067 reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
15068 reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
15075 getDispatcher()->vkCmdEndRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
15083 "Function <vkGetSwapchainStatusKHR> needs extension <VK_KHR_shared_presentable_image> enabled!" );
15085 VkResult result = getDispatcher()->vkGetSwapchainStatusKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) );
15086 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
15099 "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> needs extension <VK_KHR_external_fence_capabilities> enabled!" );
15102 getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15103 reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
15104 reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
15106 return externalFenceProperties;
15109 # if defined( VK_USE_PLATFORM_WIN32_KHR )
15112 VULKAN_HPP_INLINE void Device::importFenceWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo )
const
15115 "Function <vkImportFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" );
15117 VkResult result = getDispatcher()->vkImportFenceWin32HandleKHR(
15118 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) );
15123 Device::getFenceWin32HandleKHR(
const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo )
const
15126 "Function <vkGetFenceWin32HandleKHR> needs extension <VK_KHR_external_fence_win32> enabled!" );
15129 VkResult result = getDispatcher()->vkGetFenceWin32HandleKHR(
15130 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle );
15144 getDispatcher()->vkImportFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) );
15153 VkResult result = getDispatcher()->vkGetFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd );
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
15166 "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> needs extension <VK_KHR_performance_query> enabled!" );
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;
15175 result = getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
15176 static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &counterCount,
nullptr,
nullptr );
15177 if ( ( result ==
VK_SUCCESS ) && counterCount )
15179 counters.resize( counterCount );
15180 counterDescriptions.resize( counterCount );
15181 result = getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
15182 static_cast<VkPhysicalDevice>( m_physicalDevice ),
15185 reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
15186 reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) );
15189 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
15192 if ( counterCount < counters.size() )
15194 counters.resize( counterCount );
15195 counterDescriptions.resize( counterCount );
15204 "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> needs extension <VK_KHR_performance_query> enabled!" );
15206 uint32_t numPasses;
15207 getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
15208 static_cast<VkPhysicalDevice>( m_physicalDevice ),
15209 reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ),
15218 "Function <vkAcquireProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" );
15221 getDispatcher()->vkAcquireProfilingLockKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) );
15228 "Function <vkReleaseProfilingLockKHR> needs extension <VK_KHR_performance_query> enabled!" );
15230 getDispatcher()->vkReleaseProfilingLockKHR( static_cast<VkDevice>( m_device ) );
15239 "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" );
15242 VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15243 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15244 reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) );
15247 return surfaceCapabilities;
15250 template <
typename X,
typename Y,
typename...
Z>
15255 "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" );
15259 VkResult result = getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15260 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15261 reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) );
15264 return structureChain;
15271 "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" );
15273 std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats;
15274 uint32_t surfaceFormatCount;
15278 result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15279 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15280 &surfaceFormatCount,
15282 if ( ( result ==
VK_SUCCESS ) && surfaceFormatCount )
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() ) );
15293 if ( surfaceFormatCount < surfaceFormats.size() )
15295 surfaceFormats.resize( surfaceFormatCount );
15297 return surfaceFormats;
15300 template <
typename StructureChain>
15305 "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> needs extension <VK_KHR_get_surface_capabilities2> enabled!" );
15307 std::vector<StructureChain> structureChains;
15308 std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats;
15309 uint32_t surfaceFormatCount;
15313 result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15314 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15315 &surfaceFormatCount,
15317 if ( ( result ==
VK_SUCCESS ) && surfaceFormatCount )
15319 structureChains.resize( surfaceFormatCount );
15320 surfaceFormats.resize( surfaceFormatCount );
15321 for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
15323 surfaceFormats[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>().pNext;
15325 result = getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15326 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
15327 &surfaceFormatCount,
15328 reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) );
15333 if ( surfaceFormatCount < surfaceFormats.size() )
15335 structureChains.resize( surfaceFormatCount );
15337 for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
15339 structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>() = surfaceFormats[i];
15341 return structureChains;
15349 "Function <vkGetPhysicalDeviceDisplayProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
15351 std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> properties;
15352 uint32_t propertyCount;
15356 result = getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount,
nullptr );
15357 if ( ( result ==
VK_SUCCESS ) && propertyCount )
15359 properties.resize( propertyCount );
15360 result = getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR(
15361 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) );
15366 if ( propertyCount < properties.size() )
15368 properties.resize( propertyCount );
15376 "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
15378 std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> properties;
15379 uint32_t propertyCount;
15383 result = getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount,
nullptr );
15384 if ( ( result ==
VK_SUCCESS ) && propertyCount )
15386 properties.resize( propertyCount );
15387 result = getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
15388 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) );
15393 if ( propertyCount < properties.size() )
15395 properties.resize( propertyCount );
15403 "Function <vkGetDisplayModeProperties2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
15405 std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> properties;
15406 uint32_t propertyCount;
15410 result = getDispatcher()->vkGetDisplayModeProperties2KHR(
15411 static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ), &propertyCount,
nullptr );
15412 if ( ( result ==
VK_SUCCESS ) && propertyCount )
15414 properties.resize( propertyCount );
15415 result = getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15416 static_cast<VkDisplayKHR>( m_display ),
15418 reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) );
15423 if ( propertyCount < properties.size() )
15425 properties.resize( propertyCount );
15434 "Function <vkGetDisplayPlaneCapabilities2KHR> needs extension <VK_KHR_get_display_properties2> enabled!" );
15437 VkResult result = getDispatcher()->vkGetDisplayPlaneCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15438 reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ),
15439 reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) );
15442 return capabilities;
15445 # if defined( VK_USE_PLATFORM_IOS_MVK )
15449 Instance::createIOSSurfaceMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK
const & createInfo,
15456 # if defined( VK_USE_PLATFORM_MACOS_MVK )
15460 Instance::createMacOSSurfaceMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK
const & createInfo,
15472 "Function <vkSetDebugUtilsObjectNameEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15474 VkResult result = getDispatcher()->vkSetDebugUtilsObjectNameEXT( static_cast<VkDevice>( m_device ),
15475 reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) );
15482 "Function <vkSetDebugUtilsObjectTagEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15485 getDispatcher()->vkSetDebugUtilsObjectTagEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) );
15492 "Function <vkQueueBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15494 getDispatcher()->vkQueueBeginDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
15500 "Function <vkQueueEndDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15502 getDispatcher()->vkQueueEndDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ) );
15508 "Function <vkQueueInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15510 getDispatcher()->vkQueueInsertDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
15516 "Function <vkCmdBeginDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15518 getDispatcher()->vkCmdBeginDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15519 reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
15526 getDispatcher()->vkCmdEndDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
15532 "Function <vkCmdInsertDebugUtilsLabelEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15534 getDispatcher()->vkCmdInsertDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15535 reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
15551 "Function <vkSubmitDebugUtilsMessageEXT> needs extension <VK_EXT_debug_utils> enabled!" );
15553 getDispatcher()->vkSubmitDebugUtilsMessageEXT( static_cast<VkInstance>( m_instance ),
15554 static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
15555 static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
15556 reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) );
15559 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
15563 Device::getAndroidHardwareBufferPropertiesANDROID(
const struct AHardwareBuffer &
buffer )
const
15567 "Function <vkGetAndroidHardwareBufferPropertiesANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
15569 VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties;
15570 VkResult result = getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
15571 static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) );
15577 template <
typename X,
typename Y,
typename...
Z>
15579 Device::getAndroidHardwareBufferPropertiesANDROID(
const struct AHardwareBuffer & buffer )
const
15583 "Function <vkGetAndroidHardwareBufferPropertiesANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
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 ) );
15592 return structureChain;
15596 Device::getMemoryAndroidHardwareBufferANDROID(
const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info )
const
15599 "Function <vkGetMemoryAndroidHardwareBufferANDROID> needs extension <VK_ANDROID_external_memory_android_hardware_buffer> enabled!" );
15601 struct AHardwareBuffer *
buffer;
15602 VkResult result = getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID(
15603 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer );
15616 "Function <vkCmdSetSampleLocationsEXT> needs extension <VK_EXT_sample_locations> enabled!" );
15618 getDispatcher()->vkCmdSetSampleLocationsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15619 reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) );
15626 "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> needs extension <VK_EXT_sample_locations> enabled!" );
15629 getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15630 static_cast<VkSampleCountFlagBits>(
samples ),
15631 reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) );
15633 return multisampleProperties;
15642 "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
15645 getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
15646 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
15647 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
15649 return memoryRequirements;
15652 template <
typename X,
typename Y,
typename...
Z>
15657 "Function <vkGetImageMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
15661 getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
15662 reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
15663 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
15665 return structureChain;
15672 "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
15675 getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
15676 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
15677 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
15679 return memoryRequirements;
15682 template <
typename X,
typename Y,
typename...
Z>
15687 "Function <vkGetBufferMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
15691 getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
15692 reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
15693 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
15695 return structureChain;
15702 "Function <vkGetImageSparseMemoryRequirements2KHR> needs extension <VK_KHR_get_memory_requirements2> enabled!" );
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() ) );
15714 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
15715 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
15717 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
15719 return sparseMemoryRequirements;
15736 "Function <vkCmdBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15737 if ( infos.
size() != pBuildRangeInfos.
size() )
15742 getDispatcher()->vkCmdBuildAccelerationStructuresKHR(
15743 static_cast<VkCommandBuffer>( m_commandBuffer ),
15746 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.
data() ) );
15756 "Function <vkCmdBuildAccelerationStructuresIndirectKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15757 if ( infos.
size() != indirectDeviceAddresses.
size() )
15760 "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" );
15762 if ( infos.
size() != indirectStrides.
size() )
15766 if ( infos.
size() != pMaxPrimitiveCounts.
size() )
15771 getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15774 reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.
data() ),
15775 indirectStrides.
data(),
15776 pMaxPrimitiveCounts.
data() );
15785 "Function <vkBuildAccelerationStructuresKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15786 if ( infos.
size() != pBuildRangeInfos.
size() )
15791 VkResult result = getDispatcher()->vkBuildAccelerationStructuresKHR(
15792 static_cast<VkDevice>( m_device ),
15793 static_cast<VkDeferredOperationKHR>( deferredOperation ),
15796 reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.
data() ) );
15797 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
15811 "Function <vkCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
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 ),
15830 "Function <vkCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
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 ),
15850 "Function <vkCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
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 ),
15865 template <
typename DataType>
15873 "Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15876 std::vector<DataType>
data( dataSize /
sizeof(
DataType ) );
15878 getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast<VkDevice>( m_device ),
15879 accelerationStructures.
size(),
15880 reinterpret_cast<const VkAccelerationStructureKHR *
>( accelerationStructures.
data() ),
15881 static_cast<VkQueryType>( queryType ),
15883 reinterpret_cast<void *>( data.data() ),
15890 template <
typename DataType>
15897 "Function <vkWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15901 getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast<VkDevice>( m_device ),
15902 accelerationStructures.
size(),
15903 reinterpret_cast<const VkAccelerationStructureKHR *
>( accelerationStructures.
data() ),
15904 static_cast<VkQueryType>( queryType ),
15906 reinterpret_cast<void *>( &data ),
15917 "Function <vkCmdCopyAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15919 getDispatcher()->vkCmdCopyAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15920 reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
15927 "Function <vkCmdCopyAccelerationStructureToMemoryKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15929 getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15930 reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
15937 "Function <vkCmdCopyMemoryToAccelerationStructureKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15939 getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15940 reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
15947 "Function <vkGetAccelerationStructureDeviceAddressKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15949 VkDeviceAddress result = getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR(
15950 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) );
15959 uint32_t firstQuery )
const VULKAN_HPP_NOEXCEPT
15962 "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
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 ),
15976 "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15979 getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR( static_cast<VkDevice>( m_device ),
15980 reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ),
15981 reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
15983 return compatibility;
15992 "Function <vkGetAccelerationStructureBuildSizesKHR> needs extension <VK_KHR_acceleration_structure> enabled!" );
15999 getDispatcher()->vkGetAccelerationStructureBuildSizesKHR( static_cast<VkDevice>( m_device ),
16000 static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
16001 reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ),
16002 maxPrimitiveCounts.
data(),
16022 "Function <vkDestroySamplerYcbcrConversionKHR> needs extension <VK_KHR_sampler_ycbcr_conversion> enabled!" );
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 ) ) );
16037 VkResult result = getDispatcher()->vkBindBufferMemory2KHR(
16047 VkResult result = getDispatcher()->vkBindImageMemory2KHR(
16057 "Function <vkGetImageDrmFormatModifierPropertiesEXT> needs extension <VK_EXT_image_drm_format_modifier> enabled!" );
16060 VkResult result = getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT(
16061 static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) );
16079 "Function <vkMergeValidationCachesEXT> needs extension <VK_EXT_validation_cache> enabled!" );
16081 VkResult result = getDispatcher()->vkMergeValidationCachesEXT( static_cast<VkDevice>( m_device ),
16082 static_cast<VkValidationCacheEXT>( m_validationCache ),
16084 reinterpret_cast<const VkValidationCacheEXT *
>( srcCaches.
data() ) );
16091 "Function <vkGetValidationCacheDataEXT> needs extension <VK_EXT_validation_cache> enabled!" );
16093 std::vector<uint8_t>
data;
16098 result = getDispatcher()->vkGetValidationCacheDataEXT(
16099 static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( m_validationCache ), &dataSize,
nullptr );
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() ) );
16109 if ( dataSize < data.size() )
16111 data.resize( dataSize );
16122 "Function <vkCmdBindShadingRateImageNV> needs extension <VK_NV_shading_rate_image> enabled!" );
16124 getDispatcher()->vkCmdBindShadingRateImageNV(
16125 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
16129 uint32_t firstViewport,
16133 "Function <vkCmdSetViewportShadingRatePaletteNV> needs extension <VK_NV_shading_rate_image> enabled!" );
16135 getDispatcher()->vkCmdSetViewportShadingRatePaletteNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16137 shadingRatePalettes.size(),
16146 "Function <vkCmdSetCoarseSampleOrderNV> needs extension <VK_NV_shading_rate_image> enabled!" );
16148 getDispatcher()->vkCmdSetCoarseSampleOrderNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16149 static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
16150 customSampleOrders.size(),
16167 "Function <vkGetAccelerationStructureMemoryRequirementsNV> needs extension <VK_NV_ray_tracing> enabled!" );
16170 getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
16171 reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
16172 reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
16174 return memoryRequirements;
16177 template <
typename X,
typename Y,
typename...
Z>
16182 "Function <vkGetAccelerationStructureMemoryRequirementsNV> needs extension <VK_NV_ray_tracing> enabled!" );
16186 getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
16187 reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
16188 reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
16190 return structureChain;
16197 "Function <vkBindAccelerationStructureMemoryNV> needs extension <VK_NV_ray_tracing> enabled!" );
16199 VkResult result = getDispatcher()->vkBindAccelerationStructureMemoryNV(
16214 "Function <vkCmdBuildAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" );
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 ) );
16232 "Function <vkCmdCopyAccelerationStructureNV> needs extension <VK_NV_ray_tracing> enabled!" );
16234 getDispatcher()->vkCmdCopyAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16235 static_cast<VkAccelerationStructureNV>(
dst ),
16236 static_cast<VkAccelerationStructureNV>(
src ),
16237 static_cast<VkCopyAccelerationStructureModeKHR>(
mode ) );
16253 uint32_t
depth )
const VULKAN_HPP_NOEXCEPT
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 ),
16290 template <
typename DataType>
16292 Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount,
size_t dataSize )
const
16295 "Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!" );
16298 std::vector<DataType>
data( dataSize /
sizeof(
DataType ) );
16299 VkResult result = getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
16300 static_cast<VkPipeline>( m_pipeline ),
16304 reinterpret_cast<void *>( data.data() ) );
16310 template <
typename DataType>
16314 "Function <vkGetRayTracingShaderGroupHandlesNV> needs extension <VK_NV_ray_tracing> enabled!" );
16317 VkResult result = getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
16318 static_cast<VkPipeline>( m_pipeline ),
16322 reinterpret_cast<void *>( &data ) );
16328 template <
typename DataType>
16332 "Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!" );
16335 std::vector<DataType>
data( dataSize /
sizeof(
DataType ) );
16336 VkResult result = getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast<VkDevice>( m_device ),
16337 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
16339 reinterpret_cast<void *>( data.data() ) );
16345 template <
typename DataType>
16349 "Function <vkGetAccelerationStructureHandleNV> needs extension <VK_NV_ray_tracing> enabled!" );
16352 VkResult result = getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast<VkDevice>( m_device ),
16353 static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
16355 reinterpret_cast<void *>( &data ) );
16365 uint32_t firstQuery )
const VULKAN_HPP_NOEXCEPT
16368 "Function <vkCmdWriteAccelerationStructuresPropertiesNV> needs extension <VK_NV_ray_tracing> enabled!" );
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 ),
16382 VkResult result = getDispatcher()->vkCompileDeferredNV( static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), shader );
16392 "Function <vkGetDescriptorSetLayoutSupportKHR> needs extension <VK_KHR_maintenance3> enabled!" );
16395 getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast<VkDevice>( m_device ),
16396 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
16397 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
16402 template <
typename X,
typename Y,
typename...
Z>
16407 "Function <vkGetDescriptorSetLayoutSupportKHR> needs extension <VK_KHR_maintenance3> enabled!" );
16411 getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast<VkDevice>( m_device ),
16412 reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
16413 reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
16415 return structureChain;
16424 uint32_t maxDrawCount,
16425 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
16428 "Function <vkCmdDrawIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" );
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 ),
16443 uint32_t maxDrawCount,
16444 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
16447 "Function <vkCmdDrawIndexedIndirectCountKHR> needs extension <VK_KHR_draw_indirect_count> enabled!" );
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 ),
16464 "Function <vkGetMemoryHostPointerPropertiesEXT> needs extension <VK_EXT_external_memory_host> enabled!" );
16468 getDispatcher()->vkGetMemoryHostPointerPropertiesEXT( static_cast<VkDevice>( m_device ),
16469 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
16471 reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) );
16474 return memoryHostPointerProperties;
16482 uint32_t marker )
const VULKAN_HPP_NOEXCEPT
16486 getDispatcher()->vkCmdWriteBufferMarkerAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
16487 static_cast<VkPipelineStageFlagBits>( pipelineStage ),
16488 static_cast<VkBuffer>( dstBuffer ),
16489 static_cast<VkDeviceSize>( dstOffset ),
16498 "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
16500 std::vector<VULKAN_HPP_NAMESPACE::TimeDomainEXT> timeDomains;
16501 uint32_t timeDomainCount;
16506 getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount,
nullptr );
16507 if ( ( result ==
VK_SUCCESS ) && timeDomainCount )
16509 timeDomains.resize( timeDomainCount );
16510 result = getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
16511 static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, reinterpret_cast<VkTimeDomainEXT *>( timeDomains.data() ) );
16516 if ( timeDomainCount < timeDomains.size() )
16518 timeDomains.resize( timeDomainCount );
16520 return timeDomains;
16527 "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
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(),
16546 "Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
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 *>( ×tampInfo ), ×tamp, &maxDeviation );
16560 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask )
const VULKAN_HPP_NOEXCEPT
16564 getDispatcher()->vkCmdDrawMeshTasksNV( static_cast<VkCommandBuffer>( m_commandBuffer ), taskCount, firstTask );
16569 uint32_t drawCount,
16570 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
16573 "Function <vkCmdDrawMeshTasksIndirectNV> needs extension <VK_NV_mesh_shader> enabled!" );
16575 getDispatcher()->vkCmdDrawMeshTasksIndirectNV(
16576 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>(
offset ), drawCount,
stride );
16583 uint32_t maxDrawCount,
16584 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
16587 "Function <vkCmdDrawMeshTasksIndirectCountNV> needs extension <VK_NV_mesh_shader> enabled!" );
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 ),
16604 "Function <vkCmdSetExclusiveScissorNV> needs extension <VK_NV_scissor_exclusive> enabled!" );
16606 getDispatcher()->vkCmdSetExclusiveScissorNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16607 firstExclusiveScissor,
16608 exclusiveScissors.size(),
16609 reinterpret_cast<const VkRect2D *
>( exclusiveScissors.data() ) );
16614 template <
typename Checkpo
intMarkerType>
16615 VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType
const & checkpointMarker )
const VULKAN_HPP_NOEXCEPT
16618 "Function <vkCmdSetCheckpointNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
16620 getDispatcher()->vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const void *>( &checkpointMarker ) );
16626 "Function <vkGetQueueCheckpointDataNV> needs extension <VK_NV_device_diagnostic_checkpoints> enabled!" );
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() ) );
16636 if ( checkpointDataCount < checkpointData.size() )
16638 checkpointData.resize( checkpointDataCount );
16640 return checkpointData;
16648 "Function <vkGetSemaphoreCounterValueKHR> needs extension <VK_KHR_timeline_semaphore> enabled!" );
16651 VkResult result = getDispatcher()->vkGetSemaphoreCounterValueKHR( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value );
16663 getDispatcher()->vkWaitSemaphoresKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout );
16664 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
16676 getDispatcher()->vkSignalSemaphoreKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) );
16685 "Function <vkInitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16687 VkResult result = getDispatcher()->vkInitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ),
16688 reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) );
16695 "Function <vkUninitializePerformanceApiINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16697 getDispatcher()->vkUninitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ) );
16703 "Function <vkCmdSetPerformanceMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16705 VkResult result = getDispatcher()->vkCmdSetPerformanceMarkerINTEL( static_cast<VkCommandBuffer>( m_commandBuffer ),
16706 reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) );
16713 "Function <vkCmdSetPerformanceStreamMarkerINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16715 VkResult result = getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL( static_cast<VkCommandBuffer>( m_commandBuffer ),
16716 reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) );
16723 "Function <vkCmdSetPerformanceOverrideINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16725 VkResult result = getDispatcher()->vkCmdSetPerformanceOverrideINTEL( static_cast<VkCommandBuffer>( m_commandBuffer ),
16726 reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) );
16739 "Function <vkQueueSetPerformanceConfigurationINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16741 VkResult result = getDispatcher()->vkQueueSetPerformanceConfigurationINTEL( static_cast<VkQueue>( m_queue ),
16742 static_cast<VkPerformanceConfigurationINTEL>( configuration ) );
16750 "Function <vkGetPerformanceParameterINTEL> needs extension <VK_INTEL_performance_query> enabled!" );
16753 VkResult result = getDispatcher()->vkGetPerformanceParameterINTEL(
16754 static_cast<VkDevice>( m_device ), static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( &value ) );
16766 getDispatcher()->vkSetLocalDimmingAMD(
16767 static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkBool32>( localDimmingEnable ) );
16770 # if defined( VK_USE_PLATFORM_FUCHSIA )
16774 Instance::createImagePipeSurfaceFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA
const & createInfo,
16781 # if defined( VK_USE_PLATFORM_METAL_EXT )
16785 Instance::createMetalSurfaceEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT
const & createInfo,
16795 PhysicalDevice::getFragmentShadingRatesKHR()
const
16798 "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" );
16800 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> fragmentShadingRates;
16801 uint32_t fragmentShadingRateCount;
16806 getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &fragmentShadingRateCount,
nullptr );
16807 if ( ( result ==
VK_SUCCESS ) && fragmentShadingRateCount )
16809 fragmentShadingRates.resize( fragmentShadingRateCount );
16810 result = getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR(
16811 static_cast<VkPhysicalDevice>( m_physicalDevice ),
16812 &fragmentShadingRateCount,
16813 reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) );
16818 if ( fragmentShadingRateCount < fragmentShadingRates.size() )
16820 fragmentShadingRates.resize( fragmentShadingRateCount );
16822 return fragmentShadingRates;
16830 "Function <vkCmdSetFragmentShadingRateKHR> needs extension <VK_KHR_fragment_shading_rate> enabled!" );
16832 getDispatcher()->vkCmdSetFragmentShadingRateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
16833 reinterpret_cast<const VkExtent2D *>( &fragmentSize ),
16834 reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
16843 "Function <vkGetBufferDeviceAddressEXT> needs extension <VK_EXT_buffer_device_address> enabled!" );
16846 getDispatcher()->vkGetBufferDeviceAddressEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
16856 "Function <vkGetPhysicalDeviceToolPropertiesEXT> needs extension <VK_EXT_tooling_info> enabled!" );
16858 std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties;
16859 uint32_t toolCount;
16863 result = getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount,
nullptr );
16864 if ( ( result ==
VK_SUCCESS ) && toolCount )
16866 toolProperties.resize( toolCount );
16867 result = getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT(
16868 static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) );
16873 if ( toolCount < toolProperties.size() )
16875 toolProperties.resize( toolCount );
16877 return toolProperties;
16887 getDispatcher()->vkWaitForPresentKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), presentId, timeout );
16888 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
16898 PhysicalDevice::getCooperativeMatrixPropertiesNV()
const
16901 "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> needs extension <VK_NV_cooperative_matrix> enabled!" );
16903 std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> properties;
16904 uint32_t propertyCount;
16909 getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount,
nullptr );
16910 if ( ( result ==
VK_SUCCESS ) && propertyCount )
16912 properties.resize( propertyCount );
16913 result = getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
16914 static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) );
16919 if ( propertyCount < properties.size() )
16921 properties.resize( propertyCount );
16929 PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV()
const
16933 "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> needs extension <VK_NV_coverage_reduction_mode> enabled!" );
16935 std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> combinations;
16936 uint32_t combinationCount;
16940 result = getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
16941 static_cast<VkPhysicalDevice>( m_physicalDevice ), &combinationCount,
nullptr );
16942 if ( ( result ==
VK_SUCCESS ) && combinationCount )
16944 combinations.resize( combinationCount );
16945 result = getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
16946 static_cast<VkPhysicalDevice>( m_physicalDevice ),
16948 reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) );
16951 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
16954 if ( combinationCount < combinations.size() )
16956 combinations.resize( combinationCount );
16958 return combinations;
16961 # if defined( VK_USE_PLATFORM_WIN32_KHR )
16968 "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
16970 std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
16971 uint32_t presentModeCount;
16975 result = getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16976 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
16979 if ( ( result ==
VK_SUCCESS ) && presentModeCount )
16981 presentModes.resize( presentModeCount );
16982 result = getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16983 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
16985 reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) );
16990 if ( presentModeCount < presentModes.size() )
16992 presentModes.resize( presentModeCount );
16994 return presentModes;
17000 "Function <vkAcquireFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
17002 VkResult result = getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) );
17009 "Function <vkReleaseFullScreenExclusiveModeEXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
17011 VkResult result = getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) );
17019 "Function <vkGetDeviceGroupSurfacePresentModes2EXT> needs extension <VK_EXT_full_screen_exclusive> enabled!" );
17022 VkResult result = getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT( static_cast<VkDevice>( m_device ),
17023 reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
17024 reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) );
17046 "Function <vkGetBufferDeviceAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
17049 getDispatcher()->vkGetBufferDeviceAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
17058 "Function <vkGetBufferOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
17061 getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
17070 "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> needs extension <VK_KHR_buffer_device_address> enabled!" );
17072 uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ),
17073 reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
17080 VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern )
const VULKAN_HPP_NOEXCEPT
17084 getDispatcher()->vkCmdSetLineStippleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
17089 VULKAN_HPP_INLINE void QueryPool::resetEXT( uint32_t firstQuery, uint32_t queryCount )
const VULKAN_HPP_NOEXCEPT
17093 getDispatcher()->vkResetQueryPoolEXT( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
17102 getDispatcher()->vkCmdSetCullModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) );
17109 getDispatcher()->vkCmdSetFrontFaceEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) );
17115 "Function <vkCmdSetPrimitiveTopologyEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17117 getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) );
17124 "Function <vkCmdSetViewportWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17126 getDispatcher()->vkCmdSetViewportWithCountEXT(
17127 static_cast<VkCommandBuffer>( m_commandBuffer ), viewports.size(),
reinterpret_cast<const VkViewport *
>( viewports.data() ) );
17134 "Function <vkCmdSetScissorWithCountEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17136 getDispatcher()->vkCmdSetScissorWithCountEXT(
17137 static_cast<VkCommandBuffer>( m_commandBuffer ), scissors.size(),
reinterpret_cast<const VkRect2D *
>( scissors.data() ) );
17141 CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding,
17148 "Function <vkCmdBindVertexBuffers2EXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17149 if ( buffers.
size() != offsets.
size() )
17157 if ( !strides.
empty() && buffers.
size() != strides.
size() )
17162 getDispatcher()->vkCmdBindVertexBuffers2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
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() ) );
17174 "Function <vkCmdSetDepthTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17176 getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) );
17182 "Function <vkCmdSetDepthWriteEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17184 getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) );
17190 "Function <vkCmdSetDepthCompareOpEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17192 getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) );
17198 "Function <vkCmdSetDepthBoundsTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17200 getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) );
17206 "Function <vkCmdSetStencilTestEnableEXT> needs extension <VK_EXT_extended_dynamic_state> enabled!" );
17208 getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) );
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 ) );
17238 "Function <vkGetDeferredOperationMaxConcurrencyKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
17241 getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) );
17249 "Function <vkGetDeferredOperationResultKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
17252 getDispatcher()->vkGetDeferredOperationResultKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) );
17260 "Function <vkDeferredOperationJoinKHR> needs extension <VK_KHR_deferred_host_operations> enabled!" );
17262 VkResult result = getDispatcher()->vkDeferredOperationJoinKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) );
17263 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
17276 "Function <vkGetPipelineExecutablePropertiesKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" );
17278 std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> properties;
17279 uint32_t executableCount;
17283 result = getDispatcher()->vkGetPipelineExecutablePropertiesKHR(
17284 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount,
nullptr );
17285 if ( ( result ==
VK_SUCCESS ) && executableCount )
17287 properties.resize( executableCount );
17288 result = getDispatcher()->vkGetPipelineExecutablePropertiesKHR( static_cast<VkDevice>( m_device ),
17289 reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ),
17291 reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) );
17296 if ( executableCount < properties.size() )
17298 properties.resize( executableCount );
17307 "Function <vkGetPipelineExecutableStatisticsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" );
17309 std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>
statistics;
17310 uint32_t statisticCount;
17314 result = getDispatcher()->vkGetPipelineExecutableStatisticsKHR(
17315 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &statisticCount,
nullptr );
17316 if ( ( result ==
VK_SUCCESS ) && statisticCount )
17318 statistics.resize( statisticCount );
17319 result = getDispatcher()->vkGetPipelineExecutableStatisticsKHR( static_cast<VkDevice>( m_device ),
17320 reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
17322 reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) );
17327 if ( statisticCount < statistics.size() )
17329 statistics.resize( statisticCount );
17338 "Function <vkGetPipelineExecutableInternalRepresentationsKHR> needs extension <VK_KHR_pipeline_executable_properties> enabled!" );
17340 std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> internalRepresentations;
17341 uint32_t internalRepresentationCount;
17345 result = getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR(
17346 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &internalRepresentationCount,
nullptr );
17347 if ( ( result ==
VK_SUCCESS ) && internalRepresentationCount )
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() ) );
17357 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
17359 VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
17360 if ( internalRepresentationCount < internalRepresentations.size() )
17362 internalRepresentations.resize( internalRepresentationCount );
17364 return internalRepresentations;
17373 "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17376 getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
17377 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
17378 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17380 return memoryRequirements;
17383 template <
typename X,
typename Y,
typename...
Z>
17388 "Function <vkGetGeneratedCommandsMemoryRequirementsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17392 getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
17393 reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
17394 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17396 return structureChain;
17403 "Function <vkCmdPreprocessGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17405 getDispatcher()->vkCmdPreprocessGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
17406 reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
17414 "Function <vkCmdExecuteGeneratedCommandsNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17416 getDispatcher()->vkCmdExecuteGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
17417 static_cast<VkBool32>( isPreprocessed ),
17418 reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
17423 uint32_t groupIndex )
const VULKAN_HPP_NOEXCEPT
17426 "Function <vkCmdBindPipelineShaderGroupNV> needs extension <VK_NV_device_generated_commands> enabled!" );
17428 getDispatcher()->vkCmdBindPipelineShaderGroupNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
17429 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
17430 static_cast<VkPipeline>( pipeline ),
17448 getDispatcher()->vkAcquireDrmDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), drmFd, static_cast<VkDisplayKHR>( display ) );
17470 "Function <vkDestroyPrivateDataSlotEXT> needs extension <VK_EXT_private_data> enabled!" );
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 ) ) );
17479 uint64_t objectHandle,
17481 uint64_t
data )
const
17485 VkResult result = getDispatcher()->vkSetPrivateDataEXT(
17486 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data );
17491 uint64_t objectHandle,
17497 getDispatcher()->vkGetPrivateDataEXT(
17498 static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
17503 # if defined( VK_ENABLE_BETA_EXTENSIONS )
17506 VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR(
const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo )
const VULKAN_HPP_NOEXCEPT
17510 getDispatcher()->vkCmdEncodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) );
17514 # if defined( VK_USE_PLATFORM_METAL_EXT )
17521 VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo;
17522 getDispatcher()->vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
17524 return metalObjectsInfo;
17527 template <
typename X,
typename Y,
typename...
Z>
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 ) );
17536 return structureChain;
17547 getDispatcher()->vkCmdSetEvent2KHR(
17548 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>(
event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
17556 getDispatcher()->vkCmdResetEvent2KHR(
17557 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>(
event ), static_cast<VkPipelineStageFlags2>( stageMask ) );
17565 if ( events.
size() != dependencyInfos.
size() )
17570 getDispatcher()->vkCmdWaitEvents2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17572 reinterpret_cast<const VkEvent *
>( events.
data() ),
17573 reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.
data() ) );
17579 "Function <vkCmdPipelineBarrier2KHR> needs extension <VK_KHR_synchronization2> enabled!" );
17581 getDispatcher()->vkCmdPipelineBarrier2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17582 reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
17587 uint32_t
query )
const VULKAN_HPP_NOEXCEPT
17591 getDispatcher()->vkCmdWriteTimestamp2KHR(
17592 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ),
query );
17600 VkResult result = getDispatcher()->vkQueueSubmit2KHR(
17601 static_cast<VkQueue>( m_queue ), submits.
size(),
reinterpret_cast<const VkSubmitInfo2 *
>( submits.
data() ), static_cast<VkFence>( fence ) );
17608 uint32_t marker )
const VULKAN_HPP_NOEXCEPT
17611 "Function <vkCmdWriteBufferMarker2AMD> needs extension <VK_KHR_synchronization2> enabled!" );
17613 getDispatcher()->vkCmdWriteBufferMarker2AMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
17614 static_cast<VkPipelineStageFlags2>( stage ),
17615 static_cast<VkBuffer>( dstBuffer ),
17616 static_cast<VkDeviceSize>( dstOffset ),
17623 "Function <vkGetQueueCheckpointData2NV> needs extension <VK_KHR_synchronization2> enabled!" );
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() ) );
17633 if ( checkpointDataCount < checkpointData.size() )
17635 checkpointData.resize( checkpointDataCount );
17637 return checkpointData;
17645 "Function <vkGetDescriptorSetLayoutSizeEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17648 getDispatcher()->vkGetDescriptorSetLayoutSizeEXT( static_cast<VkDevice>( m_device ),
17649 static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ),
17650 reinterpret_cast<VkDeviceSize *>( &layoutSizeInBytes ) );
17652 return layoutSizeInBytes;
17656 DescriptorSetLayout::getBindingOffsetEXT( uint32_t binding )
const VULKAN_HPP_NOEXCEPT
17659 "Function <vkGetDescriptorSetLayoutBindingOffsetEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17662 getDispatcher()->vkGetDescriptorSetLayoutBindingOffsetEXT(
17663 static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ), binding, reinterpret_cast<VkDeviceSize *>( &offset ) );
17668 template <
typename DescriptorType>
17675 getDispatcher()->vkGetDescriptorEXT( static_cast<VkDevice>( m_device ),
17676 reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ),
17678 reinterpret_cast<void *>( &descriptor ) );
17687 "Function <vkCmdBindDescriptorBuffersEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17689 getDispatcher()->vkCmdBindDescriptorBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17690 bindingInfos.size(),
17702 "Function <vkCmdSetDescriptorBufferOffsetsEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17703 if ( bufferIndices.
size() != offsets.
size() )
17708 getDispatcher()->vkCmdSetDescriptorBufferOffsetsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17709 static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
17710 static_cast<VkPipelineLayout>( layout ),
17712 bufferIndices.
size(),
17713 bufferIndices.
data(),
17719 uint32_t set )
const VULKAN_HPP_NOEXCEPT
17722 "Function <vkCmdBindDescriptorBufferEmbeddedSamplersEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17724 getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT(
17725 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set );
17728 template <
typename DataType>
17733 "Function <vkGetBufferOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17736 VkResult result = getDispatcher()->vkGetBufferOpaqueCaptureDescriptorDataEXT(
17737 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT *>( &info ), &data );
17743 template <
typename DataType>
17748 "Function <vkGetImageOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17751 VkResult result = getDispatcher()->vkGetImageOpaqueCaptureDescriptorDataEXT(
17752 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT *>( &info ), &data );
17758 template <
typename DataType>
17763 "Function <vkGetImageViewOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17766 VkResult result = getDispatcher()->vkGetImageViewOpaqueCaptureDescriptorDataEXT(
17767 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT *>( &info ), &data );
17773 template <
typename DataType>
17778 "Function <vkGetSamplerOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
17781 VkResult result = getDispatcher()->vkGetSamplerOpaqueCaptureDescriptorDataEXT(
17782 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT *>( &info ), &data );
17788 template <
typename DataType>
17793 "Function <vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT> needs extension <VK_EXT_descriptor_buffer> enabled!" );
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 ),
17811 "Function <vkCmdSetFragmentShadingRateEnumNV> needs extension <VK_NV_fragment_shading_rate_enums> enabled!" );
17813 getDispatcher()->vkCmdSetFragmentShadingRateEnumNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
17814 static_cast<VkFragmentShadingRateNV>( shadingRate ),
17815 reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
17820 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ )
const VULKAN_HPP_NOEXCEPT
17824 getDispatcher()->vkCmdDrawMeshTasksEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
17829 uint32_t drawCount,
17830 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
17833 "Function <vkCmdDrawMeshTasksIndirectEXT> needs extension <VK_EXT_mesh_shader> enabled!" );
17835 getDispatcher()->vkCmdDrawMeshTasksIndirectEXT(
17836 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>(
offset ), drawCount,
stride );
17843 uint32_t maxDrawCount,
17844 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
17847 "Function <vkCmdDrawMeshTasksIndirectCountEXT> needs extension <VK_EXT_mesh_shader> enabled!" );
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 ),
17864 getDispatcher()->vkCmdCopyBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( ©BufferInfo ) );
17871 getDispatcher()->vkCmdCopyImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( ©ImageInfo ) );
17878 "Function <vkCmdCopyBufferToImage2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
17880 getDispatcher()->vkCmdCopyBufferToImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17881 reinterpret_cast<const VkCopyBufferToImageInfo2 *>( ©BufferToImageInfo ) );
17888 "Function <vkCmdCopyImageToBuffer2KHR> needs extension <VK_KHR_copy_commands2> enabled!" );
17890 getDispatcher()->vkCmdCopyImageToBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17891 reinterpret_cast<const VkCopyImageToBufferInfo2 *>( ©ImageToBufferInfo ) );
17898 getDispatcher()->vkCmdBlitImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
17905 getDispatcher()->vkCmdResolveImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17906 reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
17915 "Function <vkGetImageSubresourceLayout2EXT> needs extension <VK_EXT_image_compression_control> enabled!" );
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 ) );
17926 template <
typename X,
typename Y,
typename...
Z>
17931 "Function <vkGetImageSubresourceLayout2EXT> needs extension <VK_EXT_image_compression_control> enabled!" );
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 ) );
17940 return structureChain;
17946 VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>
17947 Device::getFaultInfoEXT()
const
17951 std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>
data;
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 ),
17960 return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data );
17963 # if defined( VK_USE_PLATFORM_WIN32_KHR )
17969 "Function <vkAcquireWinrtDisplayNV> needs extension <VK_NV_acquire_winrt_display> enabled!" );
17971 VkResult result = getDispatcher()->vkAcquireWinrtDisplayNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) );
17981 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
17985 Instance::createDirectFBSurfaceEXT( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT
const & createInfo,
17988 return VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *
this, createInfo, allocator );
17992 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb )
const VULKAN_HPP_NOEXCEPT
17995 "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> needs extension <VK_EXT_directfb_surface> enabled!" );
17998 getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dfb );
18012 uint32_t
depth )
const VULKAN_HPP_NOEXCEPT
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 ),
18044 template <
typename DataType>
18046 Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount,
size_t dataSize )
const
18049 "Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18052 std::vector<DataType>
data( dataSize /
sizeof(
DataType ) );
18053 VkResult result = getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18054 static_cast<VkPipeline>( m_pipeline ),
18058 reinterpret_cast<void *>( data.data() ) );
18064 template <
typename DataType>
18068 "Function <vkGetRayTracingShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18071 VkResult result = getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18072 static_cast<VkPipeline>( m_pipeline ),
18076 reinterpret_cast<void *>( &data ) );
18082 template <
typename DataType>
18084 Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount,
size_t dataSize )
const
18087 "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18090 std::vector<DataType>
data( dataSize /
sizeof(
DataType ) );
18091 VkResult result = getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18092 static_cast<VkPipeline>( m_pipeline ),
18096 reinterpret_cast<void *>( data.data() ) );
18097 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
18103 template <
typename DataType>
18107 "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18110 VkResult result = getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18111 static_cast<VkPipeline>( m_pipeline ),
18115 reinterpret_cast<void *>( &data ) );
18116 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
18129 "Function <vkCmdTraceRaysIndirectKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
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 ) );
18143 "Function <vkGetRayTracingShaderGroupStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18145 VkDeviceSize result = getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR(
18146 static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), group, static_cast<VkShaderGroupShaderKHR>( groupShader ) );
18151 VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize )
const VULKAN_HPP_NOEXCEPT
18154 "Function <vkCmdSetRayTracingPipelineStackSizeKHR> needs extension <VK_KHR_ray_tracing_pipeline> enabled!" );
18156 getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), pipelineStackSize );
18164 VULKAN_HPP_NOEXCEPT
18167 "Function <vkCmdSetVertexInputEXT> needs extension <VK_EXT_vertex_input_dynamic_state> enabled!" );
18169 getDispatcher()->vkCmdSetVertexInputEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18170 vertexBindingDescriptions.size(),
18172 vertexAttributeDescriptions.size(),
18176 # if defined( VK_USE_PLATFORM_FUCHSIA )
18180 Device::getMemoryZirconHandleFUCHSIA(
const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo )
const
18183 "Function <vkGetMemoryZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" );
18185 zx_handle_t zirconHandle;
18186 VkResult result = getDispatcher()->vkGetMemoryZirconHandleFUCHSIA(
18187 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle );
18190 return zirconHandle;
18197 "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> needs extension <VK_FUCHSIA_external_memory> enabled!" );
18199 VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties;
18201 getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA( static_cast<VkDevice>( m_device ),
18202 static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
18204 reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) );
18207 return memoryZirconHandleProperties;
18211 # if defined( VK_USE_PLATFORM_FUCHSIA )
18215 Device::importSemaphoreZirconHandleFUCHSIA(
const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo )
const
18218 "Function <vkImportSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" );
18220 VkResult result = getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA(
18221 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) );
18226 Device::getSemaphoreZirconHandleFUCHSIA(
const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo )
const
18229 "Function <vkGetSemaphoreZirconHandleFUCHSIA> needs extension <VK_FUCHSIA_external_semaphore> enabled!" );
18231 zx_handle_t zirconHandle;
18232 VkResult result = getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA(
18233 static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle );
18236 return zirconHandle;
18240 # if defined( VK_USE_PLATFORM_FUCHSIA )
18244 Device::createBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA
const & createInfo,
18247 return VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA( *
this, createInfo, allocator );
18250 VULKAN_HPP_INLINE void BufferCollectionFUCHSIA::setImageConstraints(
const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo )
const
18253 "Function <vkSetBufferCollectionImageConstraintsFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!" );
18256 getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast<VkDevice>( m_device ),
18257 static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
18258 reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( &imageConstraintsInfo ) );
18263 BufferCollectionFUCHSIA::setBufferConstraints(
const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo )
const
18266 "Function <vkSetBufferCollectionBufferConstraintsFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!" );
18269 getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast<VkDevice>( m_device ),
18270 static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
18271 reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( &bufferConstraintsInfo ) );
18278 "Function <vkGetBufferCollectionPropertiesFUCHSIA> needs extension <VK_FUCHSIA_buffer_collection> enabled!" );
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 ) );
18293 RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI()
const
18296 "Function <vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> needs extension <VK_HUAWEI_subpass_shading> enabled!" );
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 ),
18305 return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), maxWorkgroupSize );
18311 "Function <vkCmdSubpassShadingHUAWEI> needs extension <VK_HUAWEI_subpass_shading> enabled!" );
18313 getDispatcher()->vkCmdSubpassShadingHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ) );
18322 "Function <vkCmdBindInvocationMaskHUAWEI> needs extension <VK_HUAWEI_invocation_mask> enabled!" );
18324 getDispatcher()->vkCmdBindInvocationMaskHUAWEI(
18325 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
18334 "Function <vkGetMemoryRemoteAddressNV> needs extension <VK_NV_external_memory_rdma> enabled!" );
18337 VkResult result = getDispatcher()->vkGetMemoryRemoteAddressNV( static_cast<VkDevice>( m_device ),
18338 reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ),
18339 reinterpret_cast<VkRemoteAddressNV *>( &address ) );
18351 "Function <vkGetPipelinePropertiesEXT> needs extension <VK_EXT_pipeline_properties> enabled!" );
18354 VkResult result = getDispatcher()->vkGetPipelinePropertiesEXT( static_cast<VkDevice>( m_device ),
18355 reinterpret_cast<const VkPipelineInfoEXT *>( &pipelineInfo ),
18356 reinterpret_cast<VkBaseOutStructure *>( &pipelineProperties ) );
18359 return pipelineProperties;
18364 VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints )
const VULKAN_HPP_NOEXCEPT
18367 "Function <vkCmdSetPatchControlPointsEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
18369 getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), patchControlPoints );
18375 "Function <vkCmdSetRasterizerDiscardEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
18377 getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) );
18383 "Function <vkCmdSetDepthBiasEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
18385 getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) );
18392 getDispatcher()->vkCmdSetLogicOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkLogicOp>( logicOp ) );
18398 "Function <vkCmdSetPrimitiveRestartEnableEXT> needs extension <VK_EXT_extended_dynamic_state2> enabled!" );
18400 getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) );
18403 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
18407 Instance::createScreenSurfaceQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX
const & createInfo,
18414 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
struct _screen_window & window )
const VULKAN_HPP_NOEXCEPT
18417 "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> needs extension <VK_QNX_screen_surface> enabled!" );
18420 getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &window );
18432 "Function <vkCmdSetColorWriteEnableEXT> needs extension <VK_EXT_color_write_enable> enabled!" );
18434 getDispatcher()->vkCmdSetColorWriteEnableEXT(
18435 static_cast<VkCommandBuffer>( m_commandBuffer ), colorWriteEnables.size(),
reinterpret_cast<const VkBool32 *
>( colorWriteEnables.data() ) );
18443 "Function <vkCmdTraceRaysIndirect2KHR> needs extension <VK_KHR_ray_tracing_maintenance1> enabled!" );
18445 getDispatcher()->vkCmdTraceRaysIndirect2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
18452 uint32_t instanceCount,
18453 uint32_t firstInstance )
const VULKAN_HPP_NOEXCEPT
18457 getDispatcher()->vkCmdDrawMultiEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18462 vertexInfo.stride() );
18467 uint32_t instanceCount,
18468 uint32_t firstInstance,
18473 getDispatcher()->vkCmdDrawMultiIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18478 indexInfo.stride(),
18479 static_cast<const int32_t *
>( vertexOffset ) );
18496 getDispatcher()->vkCmdBuildMicromapsEXT(
18497 static_cast<VkCommandBuffer>( m_commandBuffer ), infos.size(),
reinterpret_cast<const VkMicromapBuildInfoEXT *
>( infos.data() ) );
18506 VkResult result = getDispatcher()->vkBuildMicromapsEXT( static_cast<VkDevice>( m_device ),
18507 static_cast<VkDeferredOperationKHR>( deferredOperation ),
18510 resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ),
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 ),
18540 "Function <vkCopyMicromapToMemoryEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
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 ),
18559 "Function <vkCopyMemoryToMicromapEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
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 ),
18573 template <
typename DataType>
18581 "Function <vkWriteMicromapsPropertiesEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18584 std::vector<DataType>
data( dataSize /
sizeof(
DataType ) );
18585 VkResult result = getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast<VkDevice>( m_device ),
18587 reinterpret_cast<const VkMicromapEXT *
>( micromaps.
data() ),
18588 static_cast<VkQueryType>( queryType ),
18590 reinterpret_cast<void *>( data.data() ),
18597 template <
typename DataType>
18604 "Function <vkWriteMicromapsPropertiesEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18607 VkResult result = getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast<VkDevice>( m_device ),
18609 reinterpret_cast<const VkMicromapEXT *
>( micromaps.
data() ),
18610 static_cast<VkQueryType>( queryType ),
18612 reinterpret_cast<void *>( &data ),
18623 getDispatcher()->vkCmdCopyMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) );
18629 "Function <vkCmdCopyMicromapToMemoryEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18631 getDispatcher()->vkCmdCopyMicromapToMemoryEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18632 reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) );
18638 "Function <vkCmdCopyMemoryToMicromapEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18640 getDispatcher()->vkCmdCopyMemoryToMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18641 reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) );
18648 uint32_t firstQuery )
const VULKAN_HPP_NOEXCEPT
18651 "Function <vkCmdWriteMicromapsPropertiesEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18653 getDispatcher()->vkCmdWriteMicromapsPropertiesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18655 reinterpret_cast<const VkMicromapEXT *
>( micromaps.data() ),
18656 static_cast<VkQueryType>( queryType ),
18657 static_cast<VkQueryPool
>( queryPool ),
18665 "Function <vkGetDeviceMicromapCompatibilityEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18668 getDispatcher()->vkGetDeviceMicromapCompatibilityEXT( static_cast<VkDevice>( m_device ),
18669 reinterpret_cast<const VkMicromapVersionInfoEXT *>( &versionInfo ),
18670 reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
18672 return compatibility;
18680 "Function <vkGetMicromapBuildSizesEXT> needs extension <VK_EXT_opacity_micromap> enabled!" );
18683 getDispatcher()->vkGetMicromapBuildSizesEXT( static_cast<VkDevice>( m_device ),
18684 static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
18685 reinterpret_cast<const VkMicromapBuildInfoEXT *>( &buildInfo ),
18686 reinterpret_cast<VkMicromapBuildSizesInfoEXT *>( &sizeInfo ) );
18696 "Function <vkSetDeviceMemoryPriorityEXT> needs extension <VK_EXT_pageable_device_local_memory> enabled!" );
18698 getDispatcher()->vkSetDeviceMemoryPriorityEXT( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), priority );
18707 "Function <vkGetDeviceBufferMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
18710 getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
18711 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
18712 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
18714 return memoryRequirements;
18717 template <
typename X,
typename Y,
typename...
Z>
18722 "Function <vkGetDeviceBufferMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
18726 getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
18727 reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
18728 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
18730 return structureChain;
18737 "Function <vkGetDeviceImageMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
18740 getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
18741 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
18742 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
18744 return memoryRequirements;
18747 template <
typename X,
typename Y,
typename...
Z>
18752 "Function <vkGetDeviceImageMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
18756 getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
18757 reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
18758 reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
18760 return structureChain;
18767 "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> needs extension <VK_KHR_maintenance4> enabled!" );
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() ) );
18779 VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
18780 if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
18782 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
18784 return sparseMemoryRequirements;
18793 "Function <vkGetDescriptorSetLayoutHostMappingInfoVALVE> needs extension <VK_VALVE_descriptor_set_host_mapping> enabled!" );
18796 getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE( static_cast<VkDevice>( m_device ),
18797 reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>( &bindingReference ),
18798 reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( &hostMapping ) );
18800 return hostMapping;
18806 "Function <vkGetDescriptorSetHostMappingVALVE> needs extension <VK_VALVE_descriptor_set_host_mapping> enabled!" );
18809 getDispatcher()->vkGetDescriptorSetHostMappingVALVE( static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSet>( m_descriptorSet ), &pData );
18817 uint32_t copyCount,
18818 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
18821 "Function <vkCmdCopyMemoryIndirectNV> needs extension <VK_NV_copy_memory_indirect> enabled!" );
18823 getDispatcher()->vkCmdCopyMemoryIndirectNV(
18824 static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( copyBufferAddress ), copyCount,
stride );
18835 "Function <vkCmdCopyMemoryToImageIndirectNV> needs extension <VK_NV_copy_memory_indirect> enabled!" );
18837 getDispatcher()->vkCmdCopyMemoryToImageIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18838 static_cast<VkDeviceAddress>( copyBufferAddress ),
18839 imageSubresources.size(),
18841 static_cast<VkImage
>( dstImage ),
18842 static_cast<VkImageLayout>( dstImageLayout ),
18852 "Function <vkCmdDecompressMemoryNV> needs extension <VK_NV_memory_decompression> enabled!" );
18854 getDispatcher()->vkCmdDecompressMemoryNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18855 decompressMemoryRegions.size(),
18861 uint32_t
stride )
const VULKAN_HPP_NOEXCEPT
18864 "Function <vkCmdDecompressMemoryIndirectCountNV> needs extension <VK_NV_memory_decompression> enabled!" );
18866 getDispatcher()->vkCmdDecompressMemoryIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18867 static_cast<VkDeviceAddress>( indirectCommandsAddress ),
18868 static_cast<VkDeviceAddress>( indirectCommandsCountAddress ),
18878 "Function <vkCmdSetTessellationDomainOriginEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18880 getDispatcher()->vkCmdSetTessellationDomainOriginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18881 static_cast<VkTessellationDomainOrigin>( domainOrigin ) );
18887 "Function <vkCmdSetDepthClampEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18889 getDispatcher()->vkCmdSetDepthClampEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClampEnable ) );
18895 "Function <vkCmdSetPolygonModeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18897 getDispatcher()->vkCmdSetPolygonModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPolygonMode>( polygonMode ) );
18903 "Function <vkCmdSetRasterizationSamplesEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18905 getDispatcher()->vkCmdSetRasterizationSamplesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18906 static_cast<VkSampleCountFlagBits>( rasterizationSamples ) );
18914 "Function <vkCmdSetSampleMaskEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18916 getDispatcher()->vkCmdSetSampleMaskEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18917 static_cast<VkSampleCountFlagBits>(
samples ),
18918 reinterpret_cast<const VkSampleMask *>( sampleMask.data() ) );
18924 "Function <vkCmdSetAlphaToCoverageEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18926 getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToCoverageEnable ) );
18932 "Function <vkCmdSetAlphaToOneEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18934 getDispatcher()->vkCmdSetAlphaToOneEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToOneEnable ) );
18940 "Function <vkCmdSetLogicOpEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18942 getDispatcher()->vkCmdSetLogicOpEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( logicOpEnable ) );
18949 "Function <vkCmdSetColorBlendEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18951 getDispatcher()->vkCmdSetColorBlendEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18953 colorBlendEnables.size(),
18954 reinterpret_cast<const VkBool32 *
>( colorBlendEnables.data() ) );
18958 uint32_t firstAttachment,
18962 "Function <vkCmdSetColorBlendEquationEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18964 getDispatcher()->vkCmdSetColorBlendEquationEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18966 colorBlendEquations.size(),
18971 uint32_t firstAttachment,
18975 "Function <vkCmdSetColorWriteMaskEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18977 getDispatcher()->vkCmdSetColorWriteMaskEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18979 colorWriteMasks.size(),
18983 VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream )
const VULKAN_HPP_NOEXCEPT
18986 "Function <vkCmdSetRasterizationStreamEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18988 getDispatcher()->vkCmdSetRasterizationStreamEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), rasterizationStream );
18995 "Function <vkCmdSetConservativeRasterizationModeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
18997 getDispatcher()->vkCmdSetConservativeRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
18998 static_cast<VkConservativeRasterizationModeEXT>( conservativeRasterizationMode ) );
19001 VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT(
float extraPrimitiveOverestimationSize )
const VULKAN_HPP_NOEXCEPT
19004 "Function <vkCmdSetExtraPrimitiveOverestimationSizeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19006 getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), extraPrimitiveOverestimationSize );
19012 "Function <vkCmdSetDepthClipEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19014 getDispatcher()->vkCmdSetDepthClipEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClipEnable ) );
19020 "Function <vkCmdSetSampleLocationsEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19022 getDispatcher()->vkCmdSetSampleLocationsEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( sampleLocationsEnable ) );
19026 uint32_t firstAttachment,
19030 "Function <vkCmdSetColorBlendAdvancedEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19032 getDispatcher()->vkCmdSetColorBlendAdvancedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
19034 colorBlendAdvanced.size(),
19042 "Function <vkCmdSetProvokingVertexModeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19044 getDispatcher()->vkCmdSetProvokingVertexModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
19045 static_cast<VkProvokingVertexModeEXT>( provokingVertexMode ) );
19052 "Function <vkCmdSetLineRasterizationModeEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19054 getDispatcher()->vkCmdSetLineRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
19055 static_cast<VkLineRasterizationModeEXT>( lineRasterizationMode ) );
19061 "Function <vkCmdSetLineStippleEnableEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19063 getDispatcher()->vkCmdSetLineStippleEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stippledLineEnable ) );
19069 "Function <vkCmdSetDepthClipNegativeOneToOneEXT> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19071 getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( negativeOneToOne ) );
19077 "Function <vkCmdSetViewportWScalingEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19079 getDispatcher()->vkCmdSetViewportWScalingEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( viewportWScalingEnable ) );
19083 uint32_t firstViewport,
19087 "Function <vkCmdSetViewportSwizzleNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19089 getDispatcher()->vkCmdSetViewportSwizzleNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19091 viewportSwizzles.size(),
19098 "Function <vkCmdSetCoverageToColorEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19100 getDispatcher()->vkCmdSetCoverageToColorEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( coverageToColorEnable ) );
19103 VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation )
const VULKAN_HPP_NOEXCEPT
19106 "Function <vkCmdSetCoverageToColorLocationNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19108 getDispatcher()->vkCmdSetCoverageToColorLocationNV( static_cast<VkCommandBuffer>( m_commandBuffer ), coverageToColorLocation );
19115 "Function <vkCmdSetCoverageModulationModeNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19117 getDispatcher()->vkCmdSetCoverageModulationModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19118 static_cast<VkCoverageModulationModeNV>( coverageModulationMode ) );
19125 "Function <vkCmdSetCoverageModulationTableEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19127 getDispatcher()->vkCmdSetCoverageModulationTableEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19128 static_cast<VkBool32>( coverageModulationTableEnable ) );
19135 "Function <vkCmdSetCoverageModulationTableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19137 getDispatcher()->vkCmdSetCoverageModulationTableNV(
19138 static_cast<VkCommandBuffer>( m_commandBuffer ), coverageModulationTable.size(), coverageModulationTable.data() );
19144 "Function <vkCmdSetShadingRateImageEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19146 getDispatcher()->vkCmdSetShadingRateImageEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( shadingRateImageEnable ) );
19153 "Function <vkCmdSetRepresentativeFragmentTestEnableNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19155 getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19156 static_cast<VkBool32>( representativeFragmentTestEnable ) );
19163 "Function <vkCmdSetCoverageReductionModeNV> needs extension <VK_EXT_extended_dynamic_state3> enabled!" );
19165 getDispatcher()->vkCmdSetCoverageReductionModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19166 static_cast<VkCoverageReductionModeNV>( coverageReductionMode ) );
19174 "Function <vkGetShaderModuleIdentifierEXT> needs extension <VK_EXT_shader_module_identifier> enabled!" );
19177 getDispatcher()->vkGetShaderModuleIdentifierEXT(
19178 static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( m_shaderModule ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) );
19187 "Function <vkGetShaderModuleCreateInfoIdentifierEXT> needs extension <VK_EXT_shader_module_identifier> enabled!" );
19190 getDispatcher()->vkGetShaderModuleCreateInfoIdentifierEXT( static_cast<VkDevice>( m_device ),
19191 reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
19192 reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) );
19203 "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> needs extension <VK_NV_optical_flow> enabled!" );
19205 std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> imageFormatProperties;
19206 uint32_t formatCount;
19210 result = getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
19211 static_cast<VkPhysicalDevice>( m_physicalDevice ),
19212 reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ),
19215 if ( ( result ==
VK_SUCCESS ) && formatCount )
19217 imageFormatProperties.resize( formatCount );
19218 result = getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
19219 static_cast<VkPhysicalDevice>( m_physicalDevice ),
19220 reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ),
19222 reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( imageFormatProperties.data() ) );
19227 if ( formatCount < imageFormatProperties.size() )
19229 imageFormatProperties.resize( formatCount );
19231 return imageFormatProperties;
19246 "Function <vkBindOpticalFlowSessionImageNV> needs extension <VK_NV_optical_flow> enabled!" );
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 ) );
19261 getDispatcher()->vkCmdOpticalFlowExecuteNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19262 static_cast<VkOpticalFlowSessionNV>( session ),
19263 reinterpret_cast<const VkOpticalFlowExecuteInfoNV *>( &executeInfo ) );
19271 "Function <vkGetFramebufferTilePropertiesQCOM> needs extension <VK_QCOM_tile_properties> enabled!" );
19273 std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> properties;
19274 uint32_t propertiesCount;
19278 result = getDispatcher()->vkGetFramebufferTilePropertiesQCOM(
19279 static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( m_framebuffer ), &propertiesCount,
nullptr );
19280 if ( ( result ==
VK_SUCCESS ) && propertiesCount )
19282 properties.resize( propertiesCount );
19283 result = getDispatcher()->vkGetFramebufferTilePropertiesQCOM( static_cast<VkDevice>( m_device ),
19284 static_cast<VkFramebuffer>( m_framebuffer ),
19286 reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) );
19291 if ( propertiesCount < properties.size() )
19293 properties.resize( propertiesCount );
19302 "Function <vkGetDynamicRenderingTilePropertiesQCOM> needs extension <VK_QCOM_tile_properties> enabled!" );
19305 getDispatcher()->vkGetDynamicRenderingTilePropertiesQCOM( static_cast<VkDevice>( m_device ),
19306 reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ),
19307 reinterpret_cast<VkTilePropertiesQCOM *>( &properties ) );
PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT
void(VKAPI_PTR * PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
GLsizei GLenum GLsizei GLsizei GLuint memory
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)
VULKAN_HPP_NAMESPACE::ImageView release()
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV
PFN_dummy vkBindVideoSessionMemoryKHR_placeholder
size_t getVkHeaderVersion() const
void swap(ArAssetInfo &lhs, ArAssetInfo &rhs)
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)
void(VKAPI_PTR * PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT
PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder
PFN_vkCmdWaitEvents vkCmdWaitEvents
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD
PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
PerformanceConfigurationINTEL(std::nullptr_t)
VkResult(VKAPI_PTR * PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay)
CommandBuffer(CommandBuffer &&rhs) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::Device getDevice() const
PFN_vkBeginCommandBuffer vkBeginCommandBuffer
VkResult(VKAPI_PTR * PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
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)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
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)
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])
PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR
DisplayKHR(DisplayKHR &&rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
GLuint GLsizei const GLchar * message
PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount
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.
PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder
VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
ILMTHREAD_EXPORT Semaphore(unsigned int value=0)
VULKAN_HPP_NAMESPACE::MicromapEXT release()
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties
void(VKAPI_PTR * PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR
PFN_vkCreateRenderPass vkCreateRenderPass
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)
VkResult(VKAPI_PTR * PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
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)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id)
PFN_vkCmdDrawIndirect vkCmdDrawIndirect
PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties
VULKAN_HPP_NAMESPACE::Device getDevice() const
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable
PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX
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)
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
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)
VULKAN_HPP_NAMESPACE::Instance getInstance() const
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT
void(VKAPI_PTR * PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR
PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR
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)
PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2
VULKAN_HPP_NAMESPACE::Device release()
RenderPass(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkRenderPass renderPass, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT
PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines
PFN_vkDestroyDevice vkDestroyDevice
DescriptorSet(std::nullptr_t)
VkResult(VKAPI_PTR * PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
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)
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT
void(VKAPI_PTR * PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
VkResult(VKAPI_PTR * PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
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)
PFN_vkCmdResolveImage vkCmdResolveImage
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)
VkResult(VKAPI_PTR * PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
void(VKAPI_PTR * PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
VkResult(VKAPI_PTR * PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR
void(VKAPI_PTR * PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
PFN_vkCmdWaitEvents2 vkCmdWaitEvents2
VkResult(VKAPI_PTR * PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT
PFN_vkBindBufferMemory2 vkBindBufferMemory2
VkResult(VKAPI_PTR * PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR
PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT
void(VKAPI_PTR * PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
VkResult(VKAPI_PTR * PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
void(VKAPI_PTR * PFN_vkUninitializePerformanceApiINTEL)(VkDevice device)
m_dispatcher(rhs.m_dispatcher.release())
PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder
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))
PFN_vkDestroyPipeline vkDestroyPipeline
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)
PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR
PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR
void(VKAPI_PTR * PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2EXT *pSubresource, VkSubresourceLayout2EXT *pLayout)
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV
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)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
void clear() VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
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)
Queue(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, uint32_t queueFamilyIndex, uint32_t queueIndex)
Queue & operator=(Queue const &rhs)
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
Semaphore(std::nullptr_t)
PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT
VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT
PFN_vkQueueBindSparse vkQueueBindSparse
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR
PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT
#define VULKAN_HPP_NOEXCEPT
PFN_vkCmdBlitImage vkCmdBlitImage
VkResult(VKAPI_PTR * PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
void(VKAPI_PTR * PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
void(VKAPI_PTR * PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT
void(VKAPI_PTR * PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
PFN_vkCmdSetStencilReference vkCmdSetStencilReference
void(VKAPI_PTR * PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
ShaderModule(std::nullptr_t)
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)
void(VKAPI_PTR * PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
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)
PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD
PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT
VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
void(VKAPI_PTR * PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
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_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2
PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR
PFN_dummy vkCreateWin32SurfaceKHR_placeholder
SamplerYcbcrConversion(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkSamplerYcbcrConversion ycbcrConversion, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT
PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT
void(VKAPI_PTR * PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
void(VKAPI_PTR * PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window *window)
VULKAN_HPP_NAMESPACE::Buffer release()
Framebuffer(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkFramebuffer framebuffer, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR
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)
PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR
VULKAN_HPP_NAMESPACE::PipelineCache release()
VULKAN_HPP_NAMESPACE::PhysicalDevice release()
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)
PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance &rhs) VULKAN_HPP_NOEXCEPT
PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder
VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
DeviceMemory(std::nullptr_t)
PFN_vkCmdDispatchBase vkCmdDispatchBase
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)
void(VKAPI_PTR * PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
PFN_dummy vkCreateXcbSurfaceKHR_placeholder
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)
PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers
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)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VULKAN_HPP_NAMESPACE::Device getDevice() 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)
PFN_vkBindImageMemory2 vkBindImageMemory2
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
PFN_vkGetFenceFdKHR vkGetFenceFdKHR
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_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount
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::Device getDevice() const
PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount
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)
void clear() VULKAN_HPP_NOEXCEPT
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)
PFN_dummy vkCmdEncodeVideoKHR_placeholder
PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT
VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
DeferredOperationKHR(std::nullptr_t)
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)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR
VkResult(VKAPI_PTR * PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT
VkResult(VKAPI_PTR * PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
VkResult(VKAPI_PTR * PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
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)
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)
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)
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)
PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT
void(VKAPI_PTR * PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth)
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
VULKAN_HPP_NAMESPACE::DisplayModeKHR release()
PFN_dummy vkGetRandROutputDisplayEXT_placeholder
SwapchainKHRs(std::nullptr_t)
void(VKAPI_PTR * PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
~AccelerationStructureNV()
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)
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)
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)
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)
PFN_vkTrimCommandPool vkTrimCommandPool
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)
PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV
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)
GLsizei const GLchar *const * string
PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder
GLsizei const GLfloat * value
void(VKAPI_PTR * PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pDecodeInfo)
void(VKAPI_PTR * PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
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)
PFN_vkCreateImage vkCreateImage
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)
PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT
PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT
DisplayModeKHR & operator=(DisplayModeKHR const &rhs)
VkResult(VKAPI_PTR * PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
void(VKAPI_PTR * PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::Framebuffer release()
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)
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)
void(VKAPI_PTR * PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
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
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)
DebugUtilsMessengerEXT(std::nullptr_t)
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
PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT
VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
void clear() VULKAN_HPP_NOEXCEPT
GLuint64 GLenum handleType
VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
PFN_dummy vkCreateViSurfaceNN_placeholder
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)
PFN_dummy vkGetMemoryWin32HandleNV_placeholder
DisplayKHRs(std::nullptr_t)
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)
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR
VULKAN_HPP_NAMESPACE::Semaphore release()
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
AccelerationStructureKHR(std::nullptr_t)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
PFN_dummy vkCreateWaylandSurfaceKHR_placeholder
VULKAN_HPP_NAMESPACE::Device getDevice() const
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT
PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity
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)
VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
PFN_vkCreateRenderPass2 vkCreateRenderPass2
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
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
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)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
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)
ContextDispatcher(PFN_vkGetInstanceProcAddr getProcAddr)
PFN_vkUnmapMemory vkUnmapMemory
PFN_vkMapMemory vkMapMemory
PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT
void(VKAPI_PTR * PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
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_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetDeviceProcAddr)(VkDevice device, const char *pName)
VULKAN_HPP_NAMESPACE::Device getDevice() const
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
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)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PFN_vkGetEventStatus vkGetEventStatus
PFN_vkCopyMicromapEXT vkCopyMicromapEXT
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR
VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
VkFlags VkColorComponentFlags
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2
VULKAN_HPP_NAMESPACE::DeferredOperationKHR release()
PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD
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)
DescriptorPool(std::nullptr_t)
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)
PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR
PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress
VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
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)
PFN_dummy vkCreateIOSSurfaceMVK_placeholder
ILMTHREAD_EXPORT int value() const
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
DisplayKHRs(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, uint32_t planeIndex)
PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR
PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
VULKAN_HPP_NAMESPACE::Device getDevice() const
VkResult(VKAPI_PTR * PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
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)
VULKAN_HPP_NAMESPACE::BufferView release()
PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR
VkResult(VKAPI_PTR * PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR
void clear() VULKAN_HPP_NOEXCEPT
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
void(VKAPI_PTR * PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV
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)
PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount
PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT
VkResult(VKAPI_PTR * PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
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)
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)
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)
PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT
void(VKAPI_PTR * PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
VkResult(VKAPI_PTR * PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
BufferView(BufferView &&rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
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)
VULKAN_HPP_NAMESPACE::RenderPass release()
PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT
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::Device getDevice() const
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_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures
PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT
CuModuleNVX(CuModuleNVX &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT
PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT
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)
AccelerationStructureNV(std::nullptr_t)
PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress
uint32_t descriptorSetCount
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
PFN_vkCreateCommandPool vkCreateCommandPool
DescriptorSetLayout(DescriptorSetLayout &&rhs) VULKAN_HPP_NOEXCEPT
PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
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)
Context & operator=(Context const &)=delete
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
PFN_vkCreateQueryPool vkCreateQueryPool
PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR
void(VKAPI_PTR * PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
GLenum GLenum GLsizei void * image
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)
PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
PFN_vkDestroyRenderPass vkDestroyRenderPass
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)
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)
VULKAN_HPP_NAMESPACE::Event release()
VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
VkFlags VkPipelineStageFlags
PFN_vkCmdSetDepthBias vkCmdSetDepthBias
PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
PFN_vkDeviceWaitIdle vkDeviceWaitIdle
PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT
PFN_vkCmdSetScissor vkCmdSetScissor
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
**But if you need a result
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)
PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR
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_vkCmdNextSubpass2 vkCmdNextSubpass2
PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR
PFN_vkCmdCopyImage2 vkCmdCopyImage2
VkResult(VKAPI_PTR * PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder
DeferredOperationKHR(DeferredOperationKHR &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
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)
PFN_vkResetDescriptorPool vkResetDescriptorPool
AccelerationStructureBuildTypeKHR
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
DebugReportCallbackEXT(std::nullptr_t)
PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR
void(VKAPI_PTR * PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
PhysicalDevice(PhysicalDevice const &rhs)
VULKAN_HPP_NAMESPACE::PrivateDataSlot const & operator*() const VULKAN_HPP_NOEXCEPT
PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask
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)
VkResult(VKAPI_PTR * PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE
PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE
PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT
void(VKAPI_PTR * PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR
VkResult(VKAPI_PTR * PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR
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)
void(VKAPI_PTR * PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR
PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT
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
DescriptorSetLayout(std::nullptr_t)
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy, VisualID visualID)
PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder
void(VKAPI_PTR * PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
PFN_dummy vkGetPhysicalDeviceVideoFormatPropertiesKHR_placeholder
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
PFN_vkCreateFence vkCreateFence
PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT
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
PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR
PFN_dummy vkExportMetalObjectsEXT_placeholder
void clear() VULKAN_HPP_NOEXCEPT
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)
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)
PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR
void(VKAPI_PTR * PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
DescriptorUpdateTemplate(std::nullptr_t)
VkResult(VKAPI_PTR * PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
void clear() VULKAN_HPP_NOEXCEPT
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)
VULKAN_HPP_NAMESPACE::PipelineLayout release()
PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV
PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets
PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV
VkResult(VKAPI_PTR * PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
~DescriptorUpdateTemplate()
VULKAN_HPP_NAMESPACE::Device getDevice() const
void clear() VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
PFN_dummy vkCmdControlVideoCodingKHR_placeholder
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
PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX
void clear() VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
PFN_vkCmdResolveImage2 vkCmdResolveImage2
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)
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX
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)
VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const
PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
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)
PFN_dummy vkGetMemoryWin32HandleKHR_placeholder
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
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)
PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT
VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier
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
PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX
VkResult(VKAPI_PTR * PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT
void(VKAPI_PTR * PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer)
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)
PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV
VkResult(VKAPI_PTR * PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties)
PFN_vkCmdSetStencilOp vkCmdSetStencilOp
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)
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
PFN_vkCmdClearAttachments vkCmdClearAttachments
PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB *dfb)
m_dispatcher(rhs.m_dispatcher.release())
PFN_vkCmdEndRenderPass vkCmdEndRenderPass
PFN_vkGetDeviceQueue vkGetDeviceQueue
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT
PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR
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
CopyAccelerationStructureModeKHR
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)
Fence(Fence &&rhs) VULKAN_HPP_NOEXCEPT
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
~DebugUtilsMessengerEXT()
void(VKAPI_PTR * PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
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)
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
void clear() 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
VULKAN_HPP_NAMESPACE::SwapchainKHR release()
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)
PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT
PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL
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)
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)
PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT
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)
GLuint GLsizei const GLuint const GLintptr * offsets
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)
void(VKAPI_PTR * PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
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)
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)
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
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)
PFN_vkDestroyFence vkDestroyFence
VkResult(VKAPI_PTR * PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession)
VULKAN_HPP_NAMESPACE::DescriptorPool const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkCreateInstance)(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
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)
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)
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT
void clear() VULKAN_HPP_NOEXCEPT
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
void(VKAPI_PTR * PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
PFN_vkWaitForPresentKHR vkWaitForPresentKHR
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
PFN_vkGetQueryPoolResults vkGetQueryPoolResults
PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PipelineLayout(PipelineLayout &&rhs) VULKAN_HPP_NOEXCEPT
DisplayModeKHR(DisplayModeKHR const &rhs)
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX
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)
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)
PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV
PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT
void(VKAPI_PTR * PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
VULKAN_HPP_NAMESPACE::DescriptorSet const & operator*() const VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkQueueWaitIdle)(VkQueue queue)
PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT
PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR
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)
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkResult(VKAPI_PTR * PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT
PFN_vkGetPrivateData vkGetPrivateData
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)
PFN_vkDestroyCommandPool vkDestroyCommandPool
PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR
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)
PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
VkResult(VKAPI_PTR * PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
PFN_vkBindBufferMemory vkBindBufferMemory
PFN_vkBindImageMemory vkBindImageMemory
PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR
PFN_vkImportFenceFdKHR vkImportFenceFdKHR
PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements
void(VKAPI_PTR * PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
void(VKAPI_PTR * PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
SurfaceCounterFlagBitsEXT
GLint GLsizei GLsizei height
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
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)
PFN_vkResetCommandBuffer vkResetCommandBuffer
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV
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)
void(VKAPI_PTR * PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
void clear() VULKAN_HPP_NOEXCEPT
PFN_dummy vkCmdEndVideoCodingKHR_placeholder
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)
PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT
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)
PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV
PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT
#define VULKAN_HPP_CONST_OR_CONSTEXPR
AccelerationStructureCompatibilityKHR
~IndirectCommandsLayoutNV()
PFN_vkCmdClearColorImage vkCmdClearColorImage
uint64_t(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkCmdCopyBuffer vkCmdCopyBuffer
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)
PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder
ShaderModule(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkShaderModule shaderModule, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
ImageView(ImageView &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
void(VKAPI_PTR * PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo)
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)
VULKAN_HPP_NAMESPACE::MicromapEXT const & operator*() const VULKAN_HPP_NOEXCEPT
PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM
VkResult(VKAPI_PTR * PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
ExternalMemoryHandleTypeFlagBits
VULKAN_HPP_NAMESPACE::PipelineLayout const & operator*() const VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV
VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos)
PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage
PFN_vkGetPipelineCacheData vkGetPipelineCacheData
VkResult(VKAPI_PTR * PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR
VkResult(VKAPI_PTR * PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
VkResult(VKAPI_PTR * PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR
PFN_vkAllocateMemory vkAllocateMemory
PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR
PFN_vkCmdBlitImage2 vkCmdBlitImage2
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)
PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate
PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT
VkResult(VKAPI_PTR * PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
uint32_t commandBufferCount
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore &rhs) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::Device getDevice() const
PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR
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)
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)
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)
VULKAN_HPP_NAMESPACE::CuModuleNVX release()
PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR
PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers
bool empty() const VULKAN_HPP_NOEXCEPT
PFN_vkCmdBeginRendering vkCmdBeginRendering
VULKAN_HPP_NAMESPACE::Device getDevice() const
void clear() VULKAN_HPP_NOEXCEPT
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)
PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder
VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
PhysicalDevices(std::nullptr_t)
PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder
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)
PFN_vkCmdSetFrontFace vkCmdSetFrontFace
PFN_vkCreateDevice vkCreateDevice
PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR
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)
PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT
PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD
CommandPool(std::nullptr_t)
PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR
PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV
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)
PFN_vkCompileDeferredNV vkCompileDeferredNV
VULKAN_HPP_NAMESPACE::Device getDevice() const
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
VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const VULKAN_HPP_NOEXCEPT
DescriptorUpdateTemplate(DescriptorUpdateTemplate &&rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkDeviceWaitIdle)(VkDevice device)
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)
PFN_vkCmdExecuteCommands vkCmdExecuteCommands
VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
#define VULKAN_HPP_CONSTEXPR_14
VkResult(VKAPI_PTR * PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
DisplayModeKHR(std::nullptr_t)
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)
PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR
PFN_vkCreateImageView vkCreateImageView
PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT
PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion release()
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR
PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT
PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT
void(VKAPI_PTR * PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
void(VKAPI_PTR * PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
GLbitfield GLuint64 timeout
PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR
void(VKAPI_PTR * PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
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)
PFN_vkWaitForFences vkWaitForFences
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
PFN_dummy vkGetVideoSessionMemoryRequirementsKHR_placeholder
PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR
OpticalFlowSessionNV(std::nullptr_t)
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)
PFN_vkDestroySemaphore vkDestroySemaphore
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)
PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT
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)
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
uint64_t(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
PFN_dummy vkUpdateVideoSessionParametersKHR_placeholder
PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR
PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT
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)
PFN_vkCmdSetViewport vkCmdSetViewport
PFN_vkQueueSubmit vkQueueSubmit
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
uint32_t size() const VULKAN_HPP_NOEXCEPT
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)
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))
PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT
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)
VkResult(VKAPI_PTR * PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkDeviceAddress(VKAPI_PTR * PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
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)
VULKAN_HPP_NAMESPACE::DescriptorSetLayout release()
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)
PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT
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
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkCmdCopyImage vkCmdCopyImage
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
void(VKAPI_PTR * PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR
PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV
void(VKAPI_PTR * PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo)
SwapchainKHR(std::nullptr_t)
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)
Device(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const &physicalDevice, VkDevice device, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder
PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL
PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder
VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT
~SamplerYcbcrConversion()
void(VKAPI_PTR * PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceVersion)(uint32_t *pApiVersion)
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
PFN_dummy vkCreateMetalSurfaceEXT_placeholder
PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV
void(VKAPI_PTR * PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
PipelineCache(std::nullptr_t)
VULKAN_HPP_NAMESPACE::Device getDevice() const
uint32_t(VKAPI_PTR * PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation)
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)
PFN_dummy vkCreateMacOSSurfaceMVK_placeholder
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
VkResult(VKAPI_PTR * PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain)
PFN_vkSetEvent vkSetEvent
PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT
Context(PFN_vkGetInstanceProcAddr getInstanceProcAddr)
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
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)
Image(Image &&rhs) VULKAN_HPP_NOEXCEPT
GLint GLenum GLboolean GLsizei stride
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_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable
PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2
Framebuffer(std::nullptr_t)
PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
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)
SurfaceKHR(SurfaceKHR &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void(VKAPI_PTR * PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
GLsizei const GLenum * attachments
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)
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)
PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR
VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
PipelineLayout(std::nullptr_t)
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)
PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV
void(VKAPI_PTR * PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
PhysicalDevice & operator=(PhysicalDevice &&rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
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)
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)
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)
PFN_vkDestroyQueryPool vkDestroyQueryPool
void(VKAPI_PTR * PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT
VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
void clear() VULKAN_HPP_NOEXCEPT
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT
PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable
VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
PFN_vkResetFences vkResetFences
VULKAN_HPP_NAMESPACE::DescriptorSet release()
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT
PFN_vkCreateBufferView vkCreateBufferView
PerformanceConfigurationINTEL(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const &acquireInfo)
PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV
void(VKAPI_PTR * PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
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)
PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT
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
Device(Device &&rhs) VULKAN_HPP_NOEXCEPT
DescriptorSets(std::nullptr_t)
VkResult(VKAPI_PTR * PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo)
#define VULKAN_HPP_ASSERT
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)
void clear() VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::CommandPool const & operator*() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::Queue release()
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)
PFN_vkResetEvent vkResetEvent
void(VKAPI_PTR * PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
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)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults
VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
PhysicalDevices(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const &instance)
PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
QueryPool(QueryPool &&rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCmdSetCullMode vkCmdSetCullMode
PFN_vkCmdResetQueryPool vkCmdResetQueryPool
PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT
PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR
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_vkGetDeviceProcAddr vkGetDeviceProcAddr
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)
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)
PFN_dummy vkAcquireWinrtDisplayNV_placeholder
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display *display)
PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR
VULKAN_HPP_NAMESPACE::QueryPool release()
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)
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)
PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT
PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable
PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE
~DebugReportCallbackEXT()
VkResult(VKAPI_PTR * PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VULKAN_HPP_NAMESPACE::Device getDevice() const
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)
PFN_dummy vkDestroyVideoSessionParametersKHR_placeholder
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)
PFN_dummy vkImportFenceWin32HandleKHR_placeholder
VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
VULKAN_HPP_NAMESPACE::DisplayKHR release()
PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR
PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT
PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV
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)
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)
void(VKAPI_PTR * PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
void(VKAPI_PTR * PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
PFN_vkMergePipelineCaches vkMergePipelineCaches
#define VULKAN_HPP_NODISCARD
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo)
VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks *pAllocator)
void clear() VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::Pipeline release()
GLuint const GLchar * name
VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT
PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV
void clear() VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const
PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV
PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT
void(VKAPI_PTR * PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator)
PFN_vkQueueSubmit2 vkQueueSubmit2
VkResult(VKAPI_PTR * PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
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)
PFN_vkCreateFramebuffer vkCreateFramebuffer
VkResult(VKAPI_PTR * PFN_vkSetBufferCollectionImageConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA *pImageConstraintsInfo)
PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT
PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants
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)
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)
PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT
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)
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)
PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV
VkResult(VKAPI_PTR * PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
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)
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)
PFN_vkCmdSetEvent vkCmdSetEvent
PFN_vkDestroySampler vkDestroySampler
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
void clear() VULKAN_HPP_NOEXCEPT
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)
VULKAN_HPP_NAMESPACE::ShaderModule release()
PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect
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)
PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR
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)
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
PFN_vkDestroyImageView vkDestroyImageView
void clear() VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR
void(VKAPI_PTR * PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
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
PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder
PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder
void(VKAPI_PTR * PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT release()
PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties
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)
void(VKAPI_PTR * PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR
VkResult(VKAPI_PTR * PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation)
void(VKAPI_PTR * PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR
PFN_vkQueueWaitIdle vkQueueWaitIdle
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)
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)
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
PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
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
ValidationCacheEXT(std::nullptr_t)
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)
PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
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)
VkResult(VKAPI_PTR * PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
VkResult(VKAPI_PTR * PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
Instance(Instance &&rhs) VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
GLint GLint GLsizei GLsizei GLsizei depth
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
PFN_vkEndCommandBuffer vkEndCommandBuffer
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX
uint64_t(VKAPI_PTR * PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
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)
PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
VULKAN_HPP_NAMESPACE::Instance release()
void clear() VULKAN_HPP_NOEXCEPT
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
PFN_vkDestroyShaderModule vkDestroyShaderModule
SamplerYcbcrConversion(std::nullptr_t)
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)
PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
void(VKAPI_PTR * PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
ShaderModule(ShaderModule &&rhs) VULKAN_HPP_NOEXCEPT
auto reserve(std::back_insert_iterator< Container > it, size_t n) -> checked_ptr< typename Container::value_type >
PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR
VULKAN_HPP_NAMESPACE::Device getDevice() const
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)
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)
PFN_vkCmdResetEvent vkCmdResetEvent
PFN_vkFreeDescriptorSets vkFreeDescriptorSets
void(VKAPI_PTR * PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks *pAllocator)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV
VkResult(VKAPI_PTR * PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2
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)
ConservativeRasterizationModeEXT
VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate release()
CuFunctionNVX(std::nullptr_t)
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties
void(VKAPI_PTR * PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR
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)
PFN_vkCmdBindPipeline vkCmdBindPipeline
PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
void clear() VULKAN_HPP_NOEXCEPT
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])
void(VKAPI_PTR * PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
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)
PFN_vkCmdEndRendering vkCmdEndRendering
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
VULKAN_HPP_NAMESPACE::Device getDevice() const
PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot
void(VKAPI_PTR * PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
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)
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)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX &rhs) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_NAMESPACE::SurfaceKHR release()
void(VKAPI_PTR * PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
GLsizeiptr const void GLenum usage
void(VKAPI_PTR * PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
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)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PFN_vkResetCommandPool vkResetCommandPool
PFN_vkDestroyEvent vkDestroyEvent
PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder
PFN_vkGetDeviceQueue2 vkGetDeviceQueue2
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)
PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT
VkResult(VKAPI_PTR * PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
MicromapEXT(std::nullptr_t)
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)
PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT
void(VKAPI_PTR * PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
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)
PFN_vkCreateShaderModule vkCreateShaderModule
PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV
VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR
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)
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)
void(VKAPI_PTR * PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT
#define VULKAN_HPP_NAMESPACE_STRING
PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT
PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const VULKAN_HPP_NOEXCEPT
PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask
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)
PFN_vkCmdResetEvent2 vkCmdResetEvent2
Pipeline(Pipeline &&rhs) VULKAN_HPP_NOEXCEPT
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)
PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot
VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
PFN_dummy vkCmdDecodeVideoKHR_placeholder
void(VKAPI_PTR * PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
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)
GLenum GLsizei GLsizei GLint * values
VkResult(VKAPI_PTR * PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR
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)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR
PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
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)
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)
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)
VkResult(VKAPI_PTR * PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR
void(VKAPI_PTR * PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
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)
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_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT
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)
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV release()
PFN_vkCreateSampler vkCreateSampler
PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT
PFN_vkCreateComputePipelines vkCreateComputePipelines
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
Pipelines(std::nullptr_t)
DisplayKHR(std::nullptr_t)
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)
PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp
PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT
CuModuleNVX(std::nullptr_t)
void(VKAPI_PTR * PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT
void(VKAPI_PTR * PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
PFN_vkCmdPushConstants vkCmdPushConstants
PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage
PFN_vkCreatePipelineLayout vkCreatePipelineLayout
PFN_vkCmdFillBuffer vkCmdFillBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void(VKAPI_PTR * PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory)
PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV
VULKAN_HPP_NAMESPACE::Instance getInstance() const
PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
PFN_vkCmdDispatch vkCmdDispatch
VULKAN_HPP_NAMESPACE::Device getDevice() const
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)
VkResult(VKAPI_PTR * PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer)
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)
Semaphore(Semaphore &&rhs) VULKAN_HPP_NOEXCEPT
PerformanceConfigurationINTEL(PerformanceConfigurationINTEL &&rhs) VULKAN_HPP_NOEXCEPT
PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
void clear() VULKAN_HPP_NOEXCEPT
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
PFN_vkCmdEndQuery vkCmdEndQuery
PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT
VkResult(VKAPI_PTR * PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT
void(VKAPI_PTR * PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer)
PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV
#define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
Fence(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkFence fence, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
VULKAN_HPP_NAMESPACE::Device getDevice() const
PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2
VULKAN_HPP_NAMESPACE::ValidationCacheEXT release()
PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties
PFN_vkCreatePipelineCache vkCreatePipelineCache
VULKAN_HPP_NAMESPACE::CommandPool release()
void(VKAPI_PTR * PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
PFN_vkCmdDrawIndexed vkCmdDrawIndexed
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)
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)
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)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
void(VKAPI_PTR * PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
VULKAN_HPP_NAMESPACE::Device getDevice() const
VULKAN_HPP_NAMESPACE::DeviceMemory release()
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)
Buffer(Buffer &&rhs) VULKAN_HPP_NOEXCEPT
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)
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)
PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT
VULKAN_HPP_NAMESPACE::AccelerationStructureKHR release()
#define VK_HEADER_VERSION
PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI
PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT
PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
PFN_dummy vkGetFenceWin32HandleKHR_placeholder
PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2
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)
PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
void(VKAPI_PTR * PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
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)
PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR
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)
PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder
void(VKAPI_PTR * PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
PFN_vkQueuePresentKHR vkQueuePresentKHR
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence &rhs) VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
DebugUtilsMessengerEXT(DebugUtilsMessengerEXT &&rhs) VULKAN_HPP_NOEXCEPT
PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR
VkResult(VKAPI_PTR * PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
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)
void(VKAPI_PTR * PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
CommandBuffer(std::nullptr_t)
PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT
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)
PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR
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)
PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR
VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
VULKAN_HPP_NAMESPACE::CuFunctionNVX release()
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)
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR
PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR
PFN_dummy vkDestroyVideoSessionKHR_placeholder
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
PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer
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)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
ImageView(std::nullptr_t)
VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
void(VKAPI_PTR * PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo)
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT release()
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)
PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
VkResult(VKAPI_PTR * PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos)
PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate
ValidationCacheEXT(ValidationCacheEXT &&rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2
PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder
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)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT
PFN_vkDestroyPipelineCache vkDestroyPipelineCache
PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR
VkResult(VKAPI_PTR * PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
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)
PFN_vkCmdNextSubpass vkCmdNextSubpass
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)
PFN_vkCreateMicromapEXT vkCreateMicromapEXT
PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder
PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV
void(VKAPI_PTR * PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
PFN_dummy vkCreateXlibSurfaceKHR_placeholder
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCreateInstance vkCreateInstance
PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2
VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
PFN_dummy vkGetWinrtDisplayNV_placeholder
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)
VULKAN_HPP_NAMESPACE::Image release()
PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV
VkResult(VKAPI_PTR * PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
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)
PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue
VULKAN_HPP_NAMESPACE::Fence release()
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
PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT
VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
~PerformanceConfigurationINTEL()
void(VKAPI_PTR * PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT
PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR
BufferView(std::nullptr_t)
VkResult(VKAPI_PTR * PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable
PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR
PFN_vkFreeMemory vkFreeMemory
PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2
VULKAN_HPP_NAMESPACE::Device getDevice() const
VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo)
PFN_dummy vkCreateVideoSessionKHR_placeholder
void(VKAPI_PTR * PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
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)
PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
VkResult(VKAPI_PTR * PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment
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)
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
void clear() VULKAN_HPP_NOEXCEPT
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)
void(VKAPI_PTR * PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
PFN_vkCmdSetEvent2 vkCmdSetEvent2
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)
void(VKAPI_PTR * PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2
void clear() VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
PFN_vkSignalSemaphore vkSignalSemaphore
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)
VkResult(VKAPI_PTR * PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
RenderPass(RenderPass &&rhs) VULKAN_HPP_NOEXCEPT
PrivateDataSlot(std::nullptr_t)
Sampler(Sampler &&rhs) VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator)
PFN_vkDestroyImage vkDestroyImage
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)
PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect
PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable
void swap(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX &rhs) VULKAN_HPP_NOEXCEPT
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM
PhysicalDevice(std::nullptr_t)
PFN_vkCreateBuffer vkCreateBuffer
PFN_vkWaitSemaphores vkWaitSemaphores
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceExtensionProperties)(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
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)
VkResult(VKAPI_PTR * PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT
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)
VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
PFN_vkGetDescriptorEXT vkGetDescriptorEXT
PFN_dummy vkCreateVideoSessionParametersKHR_placeholder
void(VKAPI_PTR * PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
void clear() VULKAN_HPP_NOEXCEPT
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)
PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT
DeviceDispatcher(PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
PFN_dummy vkCmdBeginVideoCodingKHR_placeholder
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)
VkResult(VKAPI_PTR * PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
PFN_vkCreateDescriptorPool vkCreateDescriptorPool
VkResult(VKAPI_PTR * PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV
PFN_vkGetFenceStatus vkGetFenceStatus
PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR
void(VKAPI_PTR * PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
OpticalFlowSessionBindingPointNV
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)
VULKAN_HPP_NAMESPACE::Sampler release()
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties)
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)
VULKAN_HPP_NAMESPACE::CommandBuffer release()
void clear() VULKAN_HPP_NOEXCEPT
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
VULKAN_HPP_NAMESPACE::Device getDevice() const
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 clear() VULKAN_HPP_NOEXCEPT
void(VKAPI_PTR * PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
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)
PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT
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)
PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT
PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR
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)
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)
PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX
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)
PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder
PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR
PFN_vkDestroyBuffer vkDestroyBuffer
VkFlags VkQueryResultFlags
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder
void(VKAPI_PTR * PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI
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)
PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder
PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR
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)
PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR
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)
PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT
PFN_vkCreateSemaphore vkCreateSemaphore
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
void clear() VULKAN_HPP_NOEXCEPT
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)
VkResult(VKAPI_PTR * PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2
PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR
PFN_vkDestroyInstance vkDestroyInstance
PFN_vkCmdSetLineWidth vkCmdSetLineWidth
VULKAN_HPP_NAMESPACE::Device getDevice() const
VkResult(VKAPI_PTR * PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
VkResult(VKAPI_PTR * PFN_vkGetFenceStatus)(VkDevice device, VkFence fence)
IndirectCommandsLayoutNV(std::nullptr_t)
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)
VULKAN_HPP_NAMESPACE::Device getDevice() const
VkResult(VKAPI_PTR * PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, zx_handle_t *pZirconHandle)
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)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
void(VKAPI_PTR * PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
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)
VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Instance(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const &context, VkInstance instance, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT
VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
VULKAN_HPP_NAMESPACE::Device getDevice() const
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)
VULKAN_HPP_NAMESPACE::PrivateDataSlot release()
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)
PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT
VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR
PFN_vkFreeCommandBuffers vkFreeCommandBuffers
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)
Event(Event &&rhs) VULKAN_HPP_NOEXCEPT
PFN_dummy vkGetPhysicalDeviceVideoCapabilitiesKHR_placeholder
PFN_vkDestroyBufferView vkDestroyBufferView
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
PFN_vkSetPrivateData vkSetPrivateData
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
FragmentShadingRateCombinerOpKHR
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
void(VKAPI_PTR * PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer)
~AccelerationStructureKHR()
VULKAN_HPP_NAMESPACE::DescriptorPool release()
VkResult(VKAPI_PTR * PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader)
PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets
PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR
PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV
PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout
void clear() VULKAN_HPP_NOEXCEPT
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)
PFN_vkCmdBeginQuery vkCmdBeginQuery
void(VKAPI_PTR * PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo)
PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion
VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR *pDisplay)
PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR
void clear() VULKAN_HPP_NOEXCEPT
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties
PFN_dummy vkCreateAndroidSurfaceKHR_placeholder
PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2
PerformanceParameterTypeINTEL
PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR
VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void clear() VULKAN_HPP_NOEXCEPT
PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR
VkResult(VKAPI_PTR * PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const VULKAN_HPP_NOEXCEPT
PFN_dummy vkAcquireXlibDisplayEXT_placeholder
PFN_vkCreateEvent vkCreateEvent
VULKAN_HPP_NAMESPACE::Sampler const & operator*() const VULKAN_HPP_NOEXCEPT
PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV
void(VKAPI_PTR * PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
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)
PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties
PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR
PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges
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
PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout
m_dispatcher(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange(rhs.m_dispatcher, nullptr))
PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder
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)
VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(VKAPI_PTR * PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
VULKAN_HPP_NAMESPACE::AccelerationStructureNV release()
CommandBuffers(std::nullptr_t)
PFN_vkDestroyFramebuffer vkDestroyFramebuffer
PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR
VkResult(VKAPI_PTR * PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool
PFN_vkResetQueryPool vkResetQueryPool
PFN_dummy vkCreateScreenSurfaceQNX_placeholder
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass
PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
GLsizei const GLuint const GLintptr const GLsizei * strides
PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion
PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT
VkResult(VKAPI_PTR * PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
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)
PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR
VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV release()
void(VKAPI_PTR * PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
Image(VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const &device, VkImage image, VULKAN_HPP_NAMESPACE::Optional< const VULKAN_HPP_NAMESPACE::AllocationCallbacks > allocator=nullptr)
PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT
PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT
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)
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)
#define VULKAN_HPP_INLINE
void(VKAPI_PTR * PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
RenderPass(std::nullptr_t)
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)
InstanceDispatcher(PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance)
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
VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr
VkResult(VKAPI_PTR * PFN_vkGetEventStatus)(VkDevice device, VkEvent event)
PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT
VkResult(VKAPI_PTR * PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
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)
Context(Context &&rhs) VULKAN_HPP_NOEXCEPT
PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR
PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer
DebugUtilsMessageSeverityFlagBitsEXT
Queue(Queue &&rhs) VULKAN_HPP_NOEXCEPT
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
SurfaceKHR(std::nullptr_t)
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
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
PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT
PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV
QueryPool(std::nullptr_t)
PcpNodeRef_ChildrenIterator begin(const PcpNodeRef::child_const_range &r)
Support for range-based for loops for PcpNodeRef children ranges.