TheCloud/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2025-09-10 04:18:48 -04:00
Code Issues Packages Projects Releases Wiki Activity

Update Vulkan-Headers to v1.4.309 (#2088)

Browse Source 
Co-authored-by: GitHub <noreply@github.com>
This commit is contained in:
github-actions[bot] 2025-02-24 11:46:40 +01:00 committed by GitHub
parent be9459f9c3
commit 16da8bd29e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 382 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit 39f924b810e561fd86b2558b6711ca68d4363f68
Subproject commit 952f776f6573aafbb62ea717d871cd1d6816c387

20
vulkan/vulkan.cppm
View File

@ -2728,6 +2728,12 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName;
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
using VULKAN_HPP_NAMESPACE::NVPresentMeteringExtensionName;
using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//========================
//=== CONSTEXPR VALUEs ===
//========================
@ -4808,6 +4814,12 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_vertex_attribute_robustness ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV;
using VULKAN_HPP_NAMESPACE::SetPresentConfigNV;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//===============
//=== HANDLEs ===
//===============
@ -8485,6 +8497,14 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//===============================================
//=== Required exports for vk::StructureChain ===
//===============================================

56
vulkan/vulkan.hpp
View File

@ -63,7 +63,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 307, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 309, "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)
@ -8967,6 +8967,12 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessExtensionName = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringExtensionName = VK_NV_PRESENT_METERING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringSpecVersion = VK_NV_PRESENT_METERING_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
@ -15805,6 +15811,24 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<AccelerationStructureGeometryLinearSweptSpheresDataNV, AccelerationStructureGeometryKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AccelerationStructureGeometrySpheresDataNV, AccelerationStructureGeometryKHR>
{
enum
{
value = true
};
};
//=== VK_NV_linear_color_attachment ===
template <>
struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, PhysicalDeviceFeatures2>
@ -17949,6 +17973,36 @@ namespace VULKAN_HPP_NAMESPACE
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
template <>
struct StructExtends<SetPresentConfigNV, PresentInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePresentMeteringFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePresentMeteringFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
namespace detail

6
vulkan/vulkan_enums.hpp
View File

@ -1584,7 +1584,11 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_METAL_EXT*/
ePhysicalDeviceDepthClampZeroOneFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT,
ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT
ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT,
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eSetPresentConfigNV = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV,
ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
};
// wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html

45
vulkan/vulkan_extension_inspection.hpp
View File

@ -466,7 +466,11 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_external_memory_metal",
#endif /*VK_USE_PLATFORM_METAL_EXT*/
"VK_KHR_depth_clamp_zero_one",
"VK_EXT_vertex_attribute_robustness" };
"VK_EXT_vertex_attribute_robustness",
#if defined( VK_ENABLE_BETA_EXTENSIONS )
"VK_NV_present_metering"
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
};
return deviceExtensions;
}
@ -1048,12 +1052,18 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_spirv_1_4",
} } },
{ "VK_VERSION_1_2",
{ {
"VK_KHR_acceleration_structure",
} } } } },
{ "VK_KHR_ray_query",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_spirv_1_4",
} } },
{ "VK_VERSION_1_2",
{ {
"VK_KHR_acceleration_structure",
} } } } },
{ "VK_NV_shader_sm_builtins", { { "VK_VERSION_1_1", { {} } } } },
@ -1356,6 +1366,9 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_1",
{ {
"VK_KHR_vulkan_memory_model",
} } },
{ "VK_VERSION_1_2",
{ {
"VK_KHR_shader_maximal_reconvergence",
} } } } },
{ "VK_KHR_spirv_1_4",
@ -1708,7 +1721,8 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_spirv_1_4",
} } } } },
} } },
{ "VK_VERSION_1_2", { {} } } } },
{ "VK_EXT_ycbcr_2plane_444_formats",
{ { "VK_VERSION_1_0",
{ {
@ -2186,7 +2200,8 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_maintenance5",
} } } } },
} } },
{ "VK_VERSION_1_4", { {} } } } },
{ "VK_QCOM_tile_properties",
{ { "VK_VERSION_1_0",
{ {
@ -2214,7 +2229,8 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_maintenance3",
} } } } },
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_legacy_vertex_attributes",
{ { "VK_VERSION_1_0",
{ {
@ -2258,7 +2274,8 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } } } },
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_video_decode_av1",
{ { "VK_VERSION_1_0",
{ {
@ -2376,7 +2393,8 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_video_encode_queue",
"VK_KHR_format_feature_flags2",
} } } } },
} } },
{ "VK_VERSION_1_3", { {} } } } },
{ "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_cluster_acceleration_structure",
{ { "VK_VERSION_1_0",
@ -2392,8 +2410,12 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_buffer_device_address",
} } },
{ "VK_VERSION_1_2",
{ {
"VK_KHR_maintenance5",
} } } } },
} } },
{ "VK_VERSION_1_3", { {} } } } },
{ "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_MESA_image_alignment_control",
{ { "VK_VERSION_1_0",
@ -2410,8 +2432,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_KHR_video_maintenance2",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_video_decode_queue",
"VK_KHR_video_encode_queue",
"VK_KHR_video_queue",
} } } } },
{ "VK_HUAWEI_hdr_vivid",
{ { "VK_VERSION_1_0",
@ -3324,7 +3345,11 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" );
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_present_metering" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

6
vulkan/vulkan_handles.hpp
View File

@ -2040,6 +2040,12 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_vertex_attribute_robustness ===
struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
struct SetPresentConfigNV;
struct PhysicalDevicePresentMeteringFeaturesNV;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//===================================
//=== HANDLE forward declarations ===
//===================================

32
vulkan/vulkan_hash.hpp
View File

@ -11720,6 +11720,22 @@ namespace std
}
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV const & physicalDevicePresentMeteringFeaturesNV ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.presentMetering );
return seed;
}
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT>
{
@ -16094,6 +16110,22 @@ namespace std
}
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SetPresentConfigNV const & setPresentConfigNV ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.numFramesPerBatch );
VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.presentConfigFeedback );
return seed;
}
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
{

16
vulkan/vulkan_static_assertions.hpp
View File

@ -8531,4 +8531,20 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>::value,
"PhysicalDeviceVertexAttributeRobustnessFeaturesEXT is not nothrow_move_constructible!" );
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetPresentConfigNV ) == sizeof( VkSetPresentConfigNV ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>::value,
"SetPresentConfigNV is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV ) == sizeof( VkPhysicalDevicePresentMeteringFeaturesNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>::value,
"PhysicalDevicePresentMeteringFeaturesNV is not nothrow_move_constructible!" );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#endif

237
vulkan/vulkan_structs.hpp
View File

@ -82622,21 +82622,6 @@ namespace VULKAN_HPP_NAMESPACE
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsPropertiesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsPropertiesNV &
setMaxFragmentShadingRateInvocationCount( VULKAN_HPP_NAMESPACE::SampleCountFlagBits maxFragmentShadingRateInvocationCount_ ) VULKAN_HPP_NOEXCEPT
{
maxFragmentShadingRateInvocationCount = maxFragmentShadingRateInvocationCount_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>( this );
@ -96152,6 +96137,107 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDevicePresentIdFeaturesKHR;
};
#if defined( VK_ENABLE_BETA_EXTENSIONS )
// wrapper struct for struct VkPhysicalDevicePresentMeteringFeaturesNV, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentMeteringFeaturesNV.html
struct PhysicalDevicePresentMeteringFeaturesNV
{
using NativeType = VkPhysicalDevicePresentMeteringFeaturesNV;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentMeteringFeaturesNV;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDevicePresentMeteringFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 presentMetering_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, presentMetering{ presentMetering_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDevicePresentMeteringFeaturesNV( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDevicePresentMeteringFeaturesNV( VkPhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDevicePresentMeteringFeaturesNV( *reinterpret_cast<PhysicalDevicePresentMeteringFeaturesNV const *>( &rhs ) )
{
}
PhysicalDevicePresentMeteringFeaturesNV & operator=( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDevicePresentMeteringFeaturesNV & operator=( VkPhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV & setPresentMetering( VULKAN_HPP_NAMESPACE::Bool32 presentMetering_ ) VULKAN_HPP_NOEXCEPT
{
presentMetering = presentMetering_;
return *this;
}
# endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDevicePresentMeteringFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV *>( this );
}
operator VkPhysicalDevicePresentMeteringFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePresentMeteringFeaturesNV *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, presentMetering );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePresentMeteringFeaturesNV const & ) const = default;
# else
bool operator==( PhysicalDevicePresentMeteringFeaturesNV 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 ) && ( presentMetering == rhs.presentMetering );
# endif
}
bool operator!=( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePresentMeteringFeaturesNV;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 presentMetering = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDevicePresentMeteringFeaturesNV>
{
using Type = PhysicalDevicePresentMeteringFeaturesNV;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
// wrapper struct for struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.html
struct PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT
@ -100231,21 +100317,6 @@ namespace VULKAN_HPP_NAMESPACE
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsPropertiesARM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsPropertiesARM &
setSchedulingControlsFlags( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags_ ) VULKAN_HPP_NOEXCEPT
{
schedulingControlsFlags = schedulingControlsFlags_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceSchedulingControlsPropertiesARM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceSchedulingControlsPropertiesARM *>( this );
@ -133048,6 +133119,112 @@ namespace VULKAN_HPP_NAMESPACE
using Type = SetLatencyMarkerInfoNV;
};
#if defined( VK_ENABLE_BETA_EXTENSIONS )
// wrapper struct for struct VkSetPresentConfigNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetPresentConfigNV.html
struct SetPresentConfigNV
{
using NativeType = VkSetPresentConfigNV;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSetPresentConfigNV;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR
SetPresentConfigNV( uint32_t numFramesPerBatch_ = {}, uint32_t presentConfigFeedback_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, numFramesPerBatch{ numFramesPerBatch_ }
, presentConfigFeedback{ presentConfigFeedback_ }
{
}
VULKAN_HPP_CONSTEXPR SetPresentConfigNV( SetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
SetPresentConfigNV( VkSetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT : SetPresentConfigNV( *reinterpret_cast<SetPresentConfigNV const *>( &rhs ) ) {}
SetPresentConfigNV & operator=( SetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
SetPresentConfigNV & operator=( VkSetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SetPresentConfigNV const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV & setNumFramesPerBatch( uint32_t numFramesPerBatch_ ) VULKAN_HPP_NOEXCEPT
{
numFramesPerBatch = numFramesPerBatch_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV & setPresentConfigFeedback( uint32_t presentConfigFeedback_ ) VULKAN_HPP_NOEXCEPT
{
presentConfigFeedback = presentConfigFeedback_;
return *this;
}
# endif /*VULKAN_HPP_NO_SETTERS*/
operator VkSetPresentConfigNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSetPresentConfigNV *>( this );
}
operator VkSetPresentConfigNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSetPresentConfigNV *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, numFramesPerBatch, presentConfigFeedback );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SetPresentConfigNV const & ) const = default;
# else
bool operator==( SetPresentConfigNV 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 ) && ( numFramesPerBatch == rhs.numFramesPerBatch ) &&
( presentConfigFeedback == rhs.presentConfigFeedback );
# endif
}
bool operator!=( SetPresentConfigNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSetPresentConfigNV;
const void * pNext = {};
uint32_t numFramesPerBatch = {};
uint32_t presentConfigFeedback = {};
};
template <>
struct CppType<StructureType, StructureType::eSetPresentConfigNV>
{
using Type = SetPresentConfigNV;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
// wrapper struct for struct VkSetStateFlagsIndirectCommandNV, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetStateFlagsIndirectCommandNV.html
struct SetStateFlagsIndirectCommandNV

6
vulkan/vulkan_to_string.hpp
View File

@ -4948,7 +4948,11 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_METAL_EXT*/
case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR : return "PhysicalDeviceDepthClampZeroOneFeaturesKHR";
case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT: return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
default : return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case StructureType::eSetPresentConfigNV : return "SetPresentConfigNV";
case StructureType::ePhysicalDevicePresentMeteringFeaturesNV: return "PhysicalDevicePresentMeteringFeaturesNV";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}