BeeEngine/vulkan-headers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update for Vulkan-Docs 1.4.329

Browse source
This commit is contained in:
Jon Leech 2025-10-10 01:36:45 +01:00 • committed by Jon Leech
parent f5fad0a209
commit 33d7f51258
17 changed files with 1775 additions and 1395 deletions
Download patch file Download diff file Expand all files Collapse all files

1914
include/vulkan/vulkan.cppm
View file

File diff suppressed because it is too large Load diff

42
include/vulkan/vulkan.hpp
View file

@ -8,14 +8,10 @@
#ifndef VULKAN_HPP
#define VULKAN_HPP
#include <vulkan/vulkan_hpp_macros.hpp>
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
# include <cassert>
# include <cstdlib>
# include <cstring>
import VULKAN_HPP_STD_MODULE;
#else
#if !defined( VULKAN_HPP_CXX_MODULE )
// clang-format off
# include <vulkan/vulkan_hpp_macros.hpp>
// clang-format on
# include <algorithm>
# include <array> // ArrayWrapperND
# include <cassert>
@ -38,6 +34,11 @@ import VULKAN_HPP_STD_MODULE;
# if defined( VULKAN_HPP_SUPPORT_SPAN )
# include <span>
# endif
#else
# include <cassert>
# include <cstdlib>
# include <cstring>
import VULKAN_HPP_STD_MODULE;
#endif
#include <vulkan/vulkan.h>
@ -57,7 +58,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif
#endif
static_assert( VK_HEADER_VERSION == 328, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 329, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@ -9350,6 +9351,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlExtensionName = VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlSpecVersion = VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION;
//=== VK_KHR_shader_fma ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaExtensionName = VK_KHR_SHADER_FMA_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaSpecVersion = VK_KHR_SHADER_FMA_SPEC_VERSION;
//=== VK_EXT_depth_clamp_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlExtensionName = VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlSpecVersion = VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION;
@ -18956,6 +18961,25 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_shader_fma ===
template <>
struct StructExtends<PhysicalDeviceShaderFmaFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderFmaFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_depth_clamp_control ===
template <>
struct StructExtends<PhysicalDeviceDepthClampControlFeaturesEXT, PhysicalDeviceFeatures2>

17
include/vulkan/vulkan_core.h
View file

@ -69,7 +69,7 @@ extern "C" {
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 328
#define VK_HEADER_VERSION 329
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1303,6 +1303,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001,
VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR = 1000579000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000,
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR = 1000584000,
@ -13747,6 +13748,20 @@ typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR {
// VK_KHR_shader_fma is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_shader_fma 1
#define VK_KHR_SHADER_FMA_SPEC_VERSION 1
#define VK_KHR_SHADER_FMA_EXTENSION_NAME "VK_KHR_shader_fma"
typedef struct VkPhysicalDeviceShaderFmaFeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 shaderFmaFloat16;
VkBool32 shaderFmaFloat32;
VkBool32 shaderFmaFloat64;
} VkPhysicalDeviceShaderFmaFeaturesKHR;
// VK_KHR_maintenance9 is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_maintenance9 1
#define VK_KHR_MAINTENANCE_9_SPEC_VERSION 1

5
include/vulkan/vulkan_enums.hpp
View file

@ -11,9 +11,7 @@
// include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private, include "vulkan/vulkan.hpp"
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
import VULKAN_HPP_STD_MODULE;
#else
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <type_traits> // for std::underlying_type
#endif
@ -1667,6 +1665,7 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceImageAlignmentControlFeaturesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA,
ePhysicalDeviceImageAlignmentControlPropertiesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA,
eImageAlignmentControlCreateInfoMESA = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA,
ePhysicalDeviceShaderFmaFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR,
ePhysicalDeviceDepthClampControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT,
ePipelineViewportDepthClampControlCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT,
ePhysicalDeviceMaintenance9FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR,

11
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -8,9 +8,7 @@
#ifndef VULKAN_EXTENSION_INSPECTION_HPP
#define VULKAN_EXTENSION_INSPECTION_HPP
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
import VULKAN_HPP_STD_MODULE;
#else
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <map>
# include <set>
# include <string>
@ -480,6 +478,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_device_generated_commands",
"VK_KHR_maintenance8",
"VK_MESA_image_alignment_control",
"VK_KHR_shader_fma",
"VK_EXT_depth_clamp_control",
"VK_KHR_maintenance9",
"VK_KHR_video_maintenance2",
@ -3680,9 +3679,9 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_EXT_shader_float8" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) ||
( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) ||
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_maintenance9" ) ||
( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) ||
( extension == "VK_ARM_pipeline_opacity_micromap" )
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/

3
include/vulkan/vulkan_handles.hpp
View file

@ -2129,6 +2129,9 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDeviceImageAlignmentControlPropertiesMESA;
struct ImageAlignmentControlCreateInfoMESA;
//=== VK_KHR_shader_fma ===
struct PhysicalDeviceShaderFmaFeaturesKHR;
//=== VK_EXT_depth_clamp_control ===
struct PhysicalDeviceDepthClampControlFeaturesEXT;
struct PipelineViewportDepthClampControlCreateInfoEXT;

15
include/vulkan/vulkan_hash.hpp
View file

@ -13489,6 +13489,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR const & physicalDeviceShaderFmaFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat16 );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat32 );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat64 );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
{

4
include/vulkan/vulkan_hpp_macros.hpp
View file

@ -87,7 +87,7 @@
# define VULKAN_HPP_SUPPORT_SPAN
#endif
#if !defined( VULKAN_HPP_STD_MODULE ) && defined( VULKAN_HPP_ENABLE_STD_MODULE )
#if !defined( VULKAN_HPP_STD_MODULE ) && defined( __cpp_modules ) && defined( __cpp_lib_modules )
# define VULKAN_HPP_STD_MODULE std.compat
#endif
@ -310,10 +310,12 @@ namespace VULKAN_HPP_NAMESPACE
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment )
#else
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) = assignment
#endif
#if !defined( VULKAN_HPP_RAII_NAMESPACE )

2
include/vulkan/vulkan_raii.hpp
View file

@ -9,7 +9,7 @@
#define VULKAN_RAII_HPP
#include <vulkan/vulkan.hpp>
#if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <memory> // std::unique_ptr
# include <utility> // std::forward
#endif

40
include/vulkan/vulkan_shared.hpp
View file

@ -10,7 +10,7 @@
#include <vulkan/vulkan.hpp>
#if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <atomic> // std::atomic_size_t
#endif
@ -84,7 +84,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename DestructorType, typename Deleter>
struct SharedHeader
{
SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT
: parent( std::move( parent ) )
, deleter( std::move( deleter ) )
{
@ -97,7 +97,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename Deleter>
struct SharedHeader<NoDestructor, Deleter>
{
SharedHeader( Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
SharedHeader( Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
Deleter deleter;
};
@ -131,7 +131,7 @@ namespace VULKAN_HPP_NAMESPACE
public:
std::atomic_size_t m_ref_cnt{ 1 };
HeaderType m_header{};
HeaderType m_header;
};
//=====================================================================================================================
@ -282,7 +282,9 @@ namespace VULKAN_HPP_NAMESPACE
SharedHandle() = default;
template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value && !HasPoolType<T>::value>::type>
explicit SharedHandle( HandleType handle, SharedHandle<DestructorTypeOf<HandleType>> parent, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
explicit SharedHandle( HandleType handle,
SharedHandle<DestructorTypeOf<HandleType>> parent,
DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( parent ), std::move( deleter ) )
{
}
@ -299,7 +301,8 @@ namespace VULKAN_HPP_NAMESPACE
}
template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
explicit SharedHandle( HandleType handle, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT : BaseType( handle, std::move( deleter ) )
explicit SharedHandle( HandleType handle, DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( deleter ) )
{
}
@ -1051,9 +1054,9 @@ namespace VULKAN_HPP_NAMESPACE
struct ImageHeader : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>
{
ImageHeader( SharedHandle<DestructorTypeOf<Image>> parent,
typename SharedHandleTraits<Image>::deleter deleter = typename SharedHandleTraits<Image>::deleter(),
SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
ImageHeader( SharedHandle<DestructorTypeOf<Image>> parent,
typename SharedHandleTraits<Image>::deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<Image>::deleter() ),
SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
: SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>( std::move( parent ), std::move( deleter ) )
, swapchainOwned( swapchainOwned )
{
@ -1074,8 +1077,8 @@ namespace VULKAN_HPP_NAMESPACE
explicit SharedHandle( Image handle,
SharedHandle<DestructorTypeOf<Image>> parent,
SwapchainOwns swapchain_owned = SwapchainOwns::no,
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
SwapchainOwns swapchain_owned VULKAN_HPP_DEFAULT_ASSIGNMENT( SwapchainOwns::no ),
DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
{
}
@ -1092,18 +1095,19 @@ namespace VULKAN_HPP_NAMESPACE
struct SwapchainHeader
{
SwapchainHeader( SharedHandle<SurfaceKHR> surface,
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
typename SharedHandleTraits<SwapchainKHR>::deleter deleter = typename SharedHandleTraits<SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
SwapchainHeader( SharedHandle<SurfaceKHR> surface,
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
typename SharedHandleTraits<SwapchainKHR>::deleter deleter
VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<SwapchainKHR>::deleter() ) ) VULKAN_HPP_NOEXCEPT
: surface( std::move( surface ) )
, parent( std::move( parent ) )
, deleter( std::move( deleter ) )
{
}
SharedHandle<SurfaceKHR> surface{};
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent{};
typename SharedHandleTraits<SwapchainKHR>::deleter deleter{};
SharedHandle<SurfaceKHR> surface;
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent;
typename SharedHandleTraits<SwapchainKHR>::deleter deleter;
};
template <>
@ -1119,7 +1123,7 @@ namespace VULKAN_HPP_NAMESPACE
explicit SharedHandle( SwapchainKHR handle,
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
SharedHandle<SurfaceKHR> surface,
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
{
}

9
include/vulkan/vulkan_static_assertions.hpp
View file

@ -8999,6 +8999,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ImageAli
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA>::value,
"ImageAlignmentControlCreateInfoMESA is not nothrow_move_constructible!" );
//=== VK_KHR_shader_fma ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFmaFeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>::value,
"PhysicalDeviceShaderFmaFeaturesKHR is not nothrow_move_constructible!" );
//=== VK_EXT_depth_clamp_control ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClampControlFeaturesEXT ),

157
include/vulkan/vulkan_structs.hpp
View file

@ -11,8 +11,10 @@
// include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private, include "vulkan/vulkan.hpp"
#include <cstdlib> // free
#include <cstring> // strcmp
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <cstdlib> // free
# include <cstring> // strcmp
#endif
namespace VULKAN_HPP_NAMESPACE
{
@ -37817,16 +37819,16 @@ namespace VULKAN_HPP_NAMESPACE
}
public:
StructureType sType = StructureType::eDeviceCreateInfo;
const void * pNext = {};
DeviceCreateFlags flags = {};
uint32_t queueCreateInfoCount = {};
const DeviceQueueCreateInfo * pQueueCreateInfos = {};
VULKAN_HPP_DEPRECATED( "ignored" ) uint32_t enabledLayerCount;
VULKAN_HPP_DEPRECATED( "ignored" ) const char * const * ppEnabledLayerNames;
uint32_t enabledExtensionCount = {};
const char * const * ppEnabledExtensionNames = {};
const PhysicalDeviceFeatures * pEnabledFeatures = {};
StructureType sType = StructureType::eDeviceCreateInfo;
const void * pNext = {};
DeviceCreateFlags flags = {};
uint32_t queueCreateInfoCount = {};
const DeviceQueueCreateInfo * pQueueCreateInfos = {};
VULKAN_HPP_DEPRECATED( "ignored" ) uint32_t enabledLayerCount = {};
VULKAN_HPP_DEPRECATED( "ignored" ) const char * const * ppEnabledLayerNames = {};
uint32_t enabledExtensionCount = {};
const char * const * ppEnabledExtensionNames = {};
const PhysicalDeviceFeatures * pEnabledFeatures = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
@ -111491,6 +111493,137 @@ namespace VULKAN_HPP_NAMESPACE
using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features;
// wrapper struct for struct VkPhysicalDeviceShaderFmaFeaturesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFmaFeaturesKHR.html
struct PhysicalDeviceShaderFmaFeaturesKHR
{
using NativeType = VkPhysicalDeviceShaderFmaFeaturesKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFmaFeaturesKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFmaFeaturesKHR( Bool32 shaderFmaFloat16_ = {},
Bool32 shaderFmaFloat32_ = {},
Bool32 shaderFmaFloat64_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, shaderFmaFloat16{ shaderFmaFloat16_ }
, shaderFmaFloat32{ shaderFmaFloat32_ }
, shaderFmaFloat64{ shaderFmaFloat64_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFmaFeaturesKHR( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceShaderFmaFeaturesKHR( VkPhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceShaderFmaFeaturesKHR( *reinterpret_cast<PhysicalDeviceShaderFmaFeaturesKHR const *>( &rhs ) )
{
}
PhysicalDeviceShaderFmaFeaturesKHR & operator=( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceShaderFmaFeaturesKHR & operator=( VkPhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceShaderFmaFeaturesKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat16( Bool32 shaderFmaFloat16_ ) VULKAN_HPP_NOEXCEPT
{
shaderFmaFloat16 = shaderFmaFloat16_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat32( Bool32 shaderFmaFloat32_ ) VULKAN_HPP_NOEXCEPT
{
shaderFmaFloat32 = shaderFmaFloat32_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat64( Bool32 shaderFmaFloat64_ ) VULKAN_HPP_NOEXCEPT
{
shaderFmaFloat64 = shaderFmaFloat64_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceShaderFmaFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderFmaFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderFmaFeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderFmaFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderFmaFeaturesKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceShaderFmaFeaturesKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, void * const &, Bool32 const &, Bool32 const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, shaderFmaFloat16, shaderFmaFloat32, shaderFmaFloat64 );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderFmaFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFmaFloat16 == rhs.shaderFmaFloat16 ) && ( shaderFmaFloat32 == rhs.shaderFmaFloat32 ) &&
( shaderFmaFloat64 == rhs.shaderFmaFloat64 );
# endif
}
bool operator!=( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::ePhysicalDeviceShaderFmaFeaturesKHR;
void * pNext = {};
Bool32 shaderFmaFloat16 = {};
Bool32 shaderFmaFloat32 = {};
Bool32 shaderFmaFloat64 = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDeviceShaderFmaFeaturesKHR>
{
using Type = PhysicalDeviceShaderFmaFeaturesKHR;
};
#endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceShaderFmaFeaturesKHR>
{
using Type = PhysicalDeviceShaderFmaFeaturesKHR;
};
// wrapper struct for struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html
struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT

11
include/vulkan/vulkan_to_string.hpp
View file

@ -8,7 +8,9 @@
#ifndef VULKAN_TO_STRING_HPP
#define VULKAN_TO_STRING_HPP
#include <vulkan/vulkan.hpp>
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <vulkan/vulkan.hpp>
#endif
// ignore warnings on using deprecated enum values in this header
#if defined( __clang__ ) || defined( __GNUC__ )
@ -19,10 +21,8 @@
# pragma warning( disable : 4996 )
#endif
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
import VULKAN_HPP_STD_MODULE;
#else
# if __cpp_lib_format
#if !defined( VULKAN_HPP_CXX_MODULE )
# if defined( __cpp_lib_format )
# include <format> // std::format
# else
# include <sstream> // std::stringstream
@ -5417,6 +5417,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA : return "PhysicalDeviceImageAlignmentControlFeaturesMESA";
case StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA : return "PhysicalDeviceImageAlignmentControlPropertiesMESA";
case StructureType::eImageAlignmentControlCreateInfoMESA : return "ImageAlignmentControlCreateInfoMESA";
case StructureType::ePhysicalDeviceShaderFmaFeaturesKHR : return "PhysicalDeviceShaderFmaFeaturesKHR";
case StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT : return "PhysicalDeviceDepthClampControlFeaturesEXT";
case StructureType::ePipelineViewportDepthClampControlCreateInfoEXT : return "PipelineViewportDepthClampControlCreateInfoEXT";
case StructureType::ePhysicalDeviceMaintenance9FeaturesKHR : return "PhysicalDeviceMaintenance9FeaturesKHR";