kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-09-02 23:20:00 +02:00
Code Issues Packages Projects Releases Wiki Activity

[BOT] update dependencies

Browse Source
This commit is contained in:
kbJeff-8
2026-08-30 01:55:30 +00:00
committed by github-actions[bot]
parent ff1a0bb4cb
commit 0494ceff27
13 changed files with 10608 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files
third_party/vulkan/vulkan.cppm
Vendored
+2 -2
View File
@@ -24,9 +24,9 @@ VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING )
export module vulkan;
export import std;
import std;
VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 359, "Wrong VK_HEADER_VERSION!" );
VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 361, "Wrong VK_HEADER_VERSION!" );
#if defined( __clang__ )
# pragma clang diagnostic push
third_party/vulkan/vulkan.hpp
Vendored
+185 -20
View File
@@ -18,6 +18,9 @@
# include <string.h> // strnlen
# include <string> // std::string
# include <utility> // std::exchange
# if defined( __APPLE__ )
# include <cstdlib> // std::getenv
# endif
# if 17 <= VULKAN_HPP_CPP_VERSION
# include <string_view>
# endif
@@ -36,7 +39,7 @@
# endif
#endif
VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 359, "Wrong VK_HEADER_VERSION!" );
VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 361, "Wrong VK_HEADER_VERSION!" );
VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
{
@@ -87,14 +90,24 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) {}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
#else
template <typename B = T>
requires std::is_same<B, char>::value
#endif
VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string const & data ) VULKAN_HPP_NOEXCEPT
{
copy( data.data(), data.length() );
}
#if 17 <= VULKAN_HPP_CPP_VERSION
# if VULKAN_HPP_CPP_VERSION < 20
template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
# else
template <typename B = T>
requires std::is_same<B, char>::value
# endif
VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string_view data ) VULKAN_HPP_NOEXCEPT
{
copy( data.data(), data.length() );
@@ -124,14 +137,24 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
return this->data();
}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
#else
template <typename B = T>
requires std::is_same<B, char>::value
#endif
operator std::string() const
{
return std::string( this->data(), strnlen( this->data(), N ) );
}
#if 17 <= VULKAN_HPP_CPP_VERSION
# if VULKAN_HPP_CPP_VERSION < 20
template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
# else
template <typename B = T>
requires std::is_same<B, char>::value
# endif
operator std::string_view() const
{
return std::string_view( this->data(), strnlen( this->data(), N ) );
@@ -344,7 +367,12 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
{
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
# else
template <typename B = T>
requires std::is_const<B>::value
# endif
ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( list.size() ) )
, m_ptr( list.begin() )
@@ -357,9 +385,15 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
// Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
// convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
# if VULKAN_HPP_CPP_VERSION < 20
template <typename V,
typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
# else
template <typename V>
requires std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value
# endif
ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( v.size() ) )
, m_ptr( v.data() )
@@ -424,8 +458,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
{
}
template <typename B = T, typename std::enable_if<std::is_convertible<B, T>::value && std::is_lvalue_reference<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( B && value ) VULKAN_HPP_NOEXCEPT
# if VULKAN_HPP_CPP_VERSION < 20
template <typename S, typename std::enable_if<std::is_convertible<S, T>::value && std::is_lvalue_reference<S>::value, int>::type = 0>
# else
template <typename S>
requires std::is_convertible<S, T>::value && std::is_lvalue_reference<S>::value
# endif
ArrayProxyNoTemporaries( S && value ) VULKAN_HPP_NOEXCEPT
: m_count( 1 )
, m_ptr( &value )
{
@@ -448,11 +487,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
ArrayProxyNoTemporaries( T ( &&ptr )[C] ) = delete;
// Any l-value reference with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
# if VULKAN_HPP_CPP_VERSION < 20
template <typename V,
typename std::enable_if<!std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value,
int>::type = 0>
# else
template <typename V>
requires( !std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value )
# endif
ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( v.size() ) )
, m_ptr( v.data() )
@@ -460,10 +506,16 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
}
// Any l-value reference with a .begin() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
# if VULKAN_HPP_CPP_VERSION < 20
template <typename V,
typename std::enable_if<std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value,
int>::type = 0>
# else
template <typename V>
requires std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value
# endif
ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( v.size() ) )
, m_ptr( v.begin() )
@@ -605,16 +657,28 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
};
};
template <typename Type, class...>
struct IsFirstInStructureChain
{
static bool const value = false;
};
template <typename Type, typename Head, typename... Tail>
struct IsFirstInStructureChain<Type, Head, Tail...>
{
static bool const value = std::is_same<Type, Head>::value;
};
template <typename Type, class...>
struct IsPartOfStructureChain
{
static bool const valid = false;
static bool const value = false;
};
template <typename Type, typename Head, typename... Tail>
struct IsPartOfStructureChain<Type, Head, Tail...>
{
static bool const valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
static bool const value = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::value;
};
template <size_t Index, typename T, typename... ChainElements>
@@ -772,28 +836,46 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
return *this;
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename ClassType,
size_t Which = 0,
typename std::enable_if<IsFirstInStructureChain<ClassType, ChainElements...>::value && ( Which == 0 ), int>::type = 0>
# else
template <typename ClassType, size_t Which = 0>
VULKAN_HPP_NODISCARD
typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && ( Which == 0 ), bool>::type
isLinked() const VULKAN_HPP_NOEXCEPT
requires IsFirstInStructureChain<ClassType, ChainElements...>::value && ( Which == 0 )
# endif
VULKAN_HPP_NODISCARD bool isLinked() const VULKAN_HPP_NOEXCEPT
{
return true;
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename ClassType,
size_t Which = 0,
typename std::enable_if<( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) &&
IsPartOfStructureChain<ClassType, ChainElements...>::value,
int>::type = 0>
# else
template <typename ClassType, size_t Which = 0>
VULKAN_HPP_NODISCARD
typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), bool>::type
isLinked() const VULKAN_HPP_NOEXCEPT
requires( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) && IsPartOfStructureChain<ClassType, ChainElements...>::value
# endif
VULKAN_HPP_NODISCARD bool isLinked() const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename ClassType,
size_t Which = 0,
typename std::enable_if<( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) &&
IsPartOfStructureChain<ClassType, ChainElements...>::value,
int>::type = 0>
# else
template <typename ClassType, size_t Which = 0>
typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
relink() VULKAN_HPP_NOEXCEPT
requires( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) && IsPartOfStructureChain<ClassType, ChainElements...>::value
# endif
void relink() VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
VULKAN_HPP_ASSERT( !isLinked( pNext ) );
auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
@@ -801,11 +883,18 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
headElement.pNext = pNext;
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename ClassType,
size_t Which = 0,
typename std::enable_if<( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) &&
IsPartOfStructureChain<ClassType, ChainElements...>::value,
int>::type = 0>
# else
template <typename ClassType, size_t Which = 0>
typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
unlink() VULKAN_HPP_NOEXCEPT
requires( !IsFirstInStructureChain<ClassType, ChainElements...>::value || ( Which != 0 ) ) && IsPartOfStructureChain<ClassType, ChainElements...>::value
# endif
void unlink() VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
}
@@ -848,16 +937,26 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
return false;
}
# if VULKAN_HPP_CPP_VERSION < 20
template <size_t Index, typename std::enable_if<Index != 0, int>::type = 0>
# else
template <size_t Index>
typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
requires( Index != 0 )
# endif
void link() VULKAN_HPP_NOEXCEPT
{
auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) );
x.pNext = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) );
link<Index - 1>();
}
# if VULKAN_HPP_CPP_VERSION < 20
template <size_t Index, typename std::enable_if<Index == 0, int>::type = 0>
# else
template <size_t Index>
typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
requires( Index == 0 )
# endif
void link() VULKAN_HPP_NOEXCEPT
{
}
@@ -9338,47 +9437,83 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
//=========================
//=== CONSTEXPR CALLEEs ===
//=========================
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
#else
template <std::integral T>
#endif
VULKAN_HPP_CONSTEXPR uint32_t apiVersionMajor( T const version )
{
return ( ( (uint32_t)( version ) >> 22U ) & 0x7FU );
}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
#else
template <std::integral T>
#endif
VULKAN_HPP_CONSTEXPR uint32_t apiVersionMinor( T const version )
{
return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
#else
template <std::integral T>
#endif
VULKAN_HPP_CONSTEXPR uint32_t apiVersionPatch( T const version )
{
return ( (uint32_t)( version ) & 0xFFFU );
}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
#else
template <std::integral T>
#endif
VULKAN_HPP_CONSTEXPR uint32_t apiVersionVariant( T const version )
{
return ( (uint32_t)( version ) >> 29U );
}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
#else
template <std::integral T>
#endif
VULKAN_HPP_CONSTEXPR uint32_t makeApiVersion( T const variant, T const major, T const minor, T const patch )
{
return ( ( ( (uint32_t)( variant ) ) << 29U ) | ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
#else
template <std::integral T>
#endif
VULKAN_HPP_CONSTEXPR uint32_t makeVersion( T const major, T const minor, T const patch )
{
return ( ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
#else
template <std::integral T>
#endif
VULKAN_HPP_CONSTEXPR uint32_t versionMajor( T const version )
{
return ( (uint32_t)( version ) >> 22U );
}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
#else
template <std::integral T>
#endif
VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version )
{
return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
}
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
#else
template <std::integral T>
#endif
VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version )
{
return ( (uint32_t)( version ) & 0xFFFU );
@@ -11413,6 +11548,17 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixDecodeVectorSpecVersion = VK_NV_COOPERATIVE_MATRIX_DECODE_VECTOR_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixDecodeVectorExtensionName = VK_NV_COOPERATIVE_MATRIX_DECODE_VECTOR_EXTENSION_NAME;
//=== VK_NV_private_data_base_handle ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVPrivateDataBaseHandleSpecVersion = VK_NV_PRIVATE_DATA_BASE_HANDLE_SPEC_VERSION;
VULKAN_HPP_CONSTEXPR_INLINE auto NVPrivateDataBaseHandleExtensionName = VK_NV_PRIVATE_DATA_BASE_HANDLE_EXTENSION_NAME;
#if 20 <= VULKAN_HPP_CPP_VERSION
template <typename Allocator, typename T>
concept IsAllocator = requires( Allocator allocator, std::size_t n ) {
{ *allocator.allocate( n ) } -> std::same_as<typename Allocator::value_type &>;
{ allocator.deallocate( allocator.allocate( n ), n ) };
} && std::copy_constructible<Allocator> && std::equality_comparable<Allocator> && std::same_as<typename Allocator ::value_type, T>;
#endif
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
@@ -23050,6 +23196,25 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_NV_private_data_base_handle ===
template <>
struct StructExtends<PhysicalDevicePrivateDataBaseHandleFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePrivateDataBaseHandleFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
namespace detail
third_party/vulkan/vulkan_core.h
Vendored
+22 -2
View File
@@ -66,7 +66,7 @@ extern "C" {
//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 359
#define VK_HEADER_VERSION 361
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@@ -1493,6 +1493,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT = 1000687000,
VK_STRUCTURE_TYPE_IMAGE_TILING_CONTROL_CREATE_INFO_EXT = 1000687001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV = 1000689000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_BASE_HANDLE_FEATURES_NV = 1000707000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
// VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a legacy alias
@@ -7127,6 +7128,11 @@ typedef enum VkToolPurposeFlagBits {
VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkToolPurposeFlagBits;
typedef VkFlags VkToolPurposeFlags;
typedef enum VkPrivateDataSlotCreateFlagBits {
VK_PRIVATE_DATA_SLOT_CREATE_BASE_OBJECT_HANDLE_BIT_NV = 0x00000001,
VK_PRIVATE_DATA_SLOT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkPrivateDataSlotCreateFlagBits;
typedef VkFlags VkPrivateDataSlotCreateFlags;
typedef VkFlags64 VkPipelineStageFlags2;
@@ -20070,6 +20076,8 @@ typedef VkPrivateDataSlot VkPrivateDataSlotEXT;
#define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data"
typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT;
typedef VkPrivateDataSlotCreateFlagBits VkPrivateDataSlotCreateFlagBitsEXT;
typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT;
typedef VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT;
@@ -24007,7 +24015,7 @@ typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
// VK_NV_low_latency2 is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_low_latency2 1
#define VK_NV_LOW_LATENCY_2_SPEC_VERSION 2
#define VK_NV_LOW_LATENCY_2_SPEC_VERSION 3
#define VK_NV_LOW_LATENCY_2_EXTENSION_NAME "VK_NV_low_latency2"
typedef enum VkLatencyMarkerNV {
@@ -26588,6 +26596,18 @@ typedef struct VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV {
// VK_NV_private_data_base_handle is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_private_data_base_handle 1
#define VK_NV_PRIVATE_DATA_BASE_HANDLE_SPEC_VERSION 1
#define VK_NV_PRIVATE_DATA_BASE_HANDLE_EXTENSION_NAME "VK_NV_private_data_base_handle"
typedef struct VkPhysicalDevicePrivateDataBaseHandleFeaturesNV {
VkStructureType sType;
void* pNext;
VkBool32 privateDataBaseHandle;
} VkPhysicalDevicePrivateDataBaseHandleFeaturesNV;
// VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_acceleration_structure 1
#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13
third_party/vulkan/vulkan_enums.hpp
Vendored
+58 -33
View File
@@ -22,6 +22,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false;
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <typename T>
concept Bitmask = FlagTraits<T>::isBitmask;
#endif
template <typename BitType>
class Flags
{
@@ -142,85 +147,101 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
// relational operators only needed for pre C++20
template <typename BitType>
VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
template <typename T>
VULKAN_HPP_CONSTEXPR bool operator<( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
{
return flags.operator>( bit );
}
template <typename BitType>
VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
template <typename T>
VULKAN_HPP_CONSTEXPR bool operator<=( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
{
return flags.operator>=( bit );
}
template <typename BitType>
VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
template <typename T>
VULKAN_HPP_CONSTEXPR bool operator>( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
{
return flags.operator<( bit );
}
template <typename BitType>
VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
template <typename T>
VULKAN_HPP_CONSTEXPR bool operator>=( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
{
return flags.operator<=( bit );
}
template <typename BitType>
VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
template <typename T>
VULKAN_HPP_CONSTEXPR bool operator==( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
{
return flags.operator==( bit );
}
template <typename BitType>
VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
template <typename T>
VULKAN_HPP_CONSTEXPR bool operator!=( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
{
return flags.operator!=( bit );
}
#endif
// bitwise operators
template <typename BitType>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
template <typename T>
VULKAN_HPP_CONSTEXPR Flags<T> operator&( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
{
return flags.operator&( bit );
}
template <typename BitType>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
template <typename T>
VULKAN_HPP_CONSTEXPR Flags<T> operator|( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
{
return flags.operator|( bit );
}
template <typename BitType>
VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
template <typename T>
VULKAN_HPP_CONSTEXPR Flags<T> operator^( T bit, Flags<T> const & flags ) VULKAN_HPP_NOEXCEPT
{
return flags.operator^( bit );
}
// bitwise operators on BitType
template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
// bitwise operators on BitType T
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<FlagTraits<T>::isBitmask, bool>::type = true>
#else
template <Bitmask T>
#endif
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<T> operator&( T lhs, T rhs ) VULKAN_HPP_NOEXCEPT
{
return Flags<BitType>( lhs ) & rhs;
return Flags<T>( lhs ) & rhs;
}
template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<FlagTraits<T>::isBitmask, bool>::type = true>
#else
template <Bitmask T>
#endif
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<T> operator|( T lhs, T rhs ) VULKAN_HPP_NOEXCEPT
{
return Flags<BitType>( lhs ) | rhs;
return Flags<T>( lhs ) | rhs;
}
template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<FlagTraits<T>::isBitmask, bool>::type = true>
#else
template <Bitmask T>
#endif
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<T> operator^( T lhs, T rhs ) VULKAN_HPP_NOEXCEPT
{
return Flags<BitType>( lhs ) ^ rhs;
return Flags<T>( lhs ) ^ rhs;
}
template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<BitType> operator~( BitType bit ) VULKAN_HPP_NOEXCEPT
#if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<FlagTraits<T>::isBitmask, bool>::type = true>
#else
template <Bitmask T>
#endif
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags<T> operator~( T bit ) VULKAN_HPP_NOEXCEPT
{
return ~( Flags<BitType>( bit ) );
return ~( Flags<T>( bit ) );
}
//=============
@@ -1871,7 +1892,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
ePhysicalDevicePrimitiveRestartIndexFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT,
ePhysicalDeviceImageTilingControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_TILING_CONTROL_FEATURES_EXT,
eImageTilingControlCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_TILING_CONTROL_CREATE_INFO_EXT,
ePhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV
ePhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV,
ePhysicalDevicePrivateDataBaseHandleFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_BASE_HANDLE_FEATURES_NV
};
// wrapper class for enum VkObjectType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkObjectType.html
@@ -5078,8 +5100,10 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
ToolPurposeFlagBits::eModifyingFeatures | ToolPurposeFlagBits::eDebugReportingEXT | ToolPurposeFlagBits::eDebugMarkersEXT;
};
// wrapper class for enum VkPrivateDataSlotCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateFlagBits.html
enum class PrivateDataSlotCreateFlagBits : VkPrivateDataSlotCreateFlags
{
eBaseObjectHandleNV = VK_PRIVATE_DATA_SLOT_CREATE_BASE_OBJECT_HANDLE_BIT_NV
};
using PrivateDataSlotCreateFlagBitsEXT = PrivateDataSlotCreateFlagBits;
@@ -5091,8 +5115,9 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
template <>
struct FlagTraits<PrivateDataSlotCreateFlagBits>
{
using WrappedType = VkPrivateDataSlotCreateFlagBits;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR PrivateDataSlotCreateFlags allFlags = {};
static VULKAN_HPP_CONST_OR_CONSTEXPR PrivateDataSlotCreateFlags allFlags = PrivateDataSlotCreateFlagBits::eBaseObjectHandleNV;
};
// wrapper class for enum VkPipelineStageFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits2.html
third_party/vulkan/vulkan_extension_inspection.hpp
Vendored
+23 -3
View File
@@ -552,7 +552,8 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
"VK_ARM_data_graph_neural_accelerator_statistics",
"VK_EXT_primitive_restart_index",
"VK_EXT_image_tiling_control",
"VK_NV_cooperative_matrix_decode_vector" };
"VK_NV_cooperative_matrix_decode_vector",
"VK_NV_private_data_base_handle" };
return deviceExtensions;
}
@@ -2450,6 +2451,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_EXT_image_compression_control",
"VK_KHR_swapchain",
} } } } },
{ "VK_QCOM_image_processing",
{ { "VK_VERSION_1_0",
@@ -3292,17 +3294,35 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
"VK_KHR_shader_float16_int8",
} } },
{ "VK_VERSION_1_2", { {} } } } },
{ "VK_ARM_data_graph_neural_accelerator_statistics",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_primitive_restart_index",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_image_tiling_control",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_cooperative_matrix_decode_vector",
{ { "VK_VERSION_1_0",
{ {
"VK_NV_cooperative_matrix2",
} } } } }
} } } } },
{ "VK_NV_private_data_base_handle",
{ { "VK_VERSION_1_0",
{ {
"VK_EXT_private_data",
} } },
{ "VK_VERSION_1_3", { {} } } } }
};
auto depIt = dependencies.find( extension );
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
@@ -4292,7 +4312,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
( extension == "VK_EXT_shader_ocp_microscaling_types" ) || ( extension == "VK_VALVE_shader_mixed_float_dot_product" ) ||
( extension == "VK_SEC_throttle_hint" ) || ( extension == "VK_ARM_data_graph_neural_accelerator_statistics" ) ||
( extension == "VK_EXT_primitive_restart_index" ) || ( extension == "VK_EXT_image_tiling_control" ) ||
( extension == "VK_NV_cooperative_matrix_decode_vector" );
( extension == "VK_NV_cooperative_matrix_decode_vector" ) || ( extension == "VK_NV_private_data_base_handle" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
third_party/vulkan/vulkan_funcs.hpp
Vendored
+4955 -4
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_handles.hpp
Vendored
+5160 -2
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_hash.hpp
Vendored
+14
View File
@@ -14423,6 +14423,20 @@ VULKAN_HPP_EXPORT namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV const & physicalDevicePrivateDataBaseHandleFeaturesNV ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataBaseHandleFeaturesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataBaseHandleFeaturesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataBaseHandleFeaturesNV.privateDataBaseHandle );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures>
{
third_party/vulkan/vulkan_raii.hpp
Vendored
+34 -2
View File
@@ -3344,6 +3344,11 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
};
# if 20 <= VULKAN_HPP_CPP_VERSION
template <typename T>
concept VulkanRAIIHandleType = isVulkanRAIIHandleType<T>::value;
# endif
class Context
{
public:
@@ -15877,51 +15882,78 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
};
// operators to compare VULKAN_HPP_NAMESPACE::raii-handles
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
# if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
# else
template <VulkanRAIIHandleType T>
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT
{
return *a <=> *b;
}
# else
template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
bool operator<( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT
{
return *a < *b;
}
# endif
# if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
# else
template <VulkanRAIIHandleType T>
# endif
bool operator==( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT
{
return *a == *b;
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
# else
template <VulkanRAIIHandleType T>
# endif
bool operator!=( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT
{
return *a != *b;
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
# else
template <VulkanRAIIHandleType T>
# endif
bool operator==( T const & v, std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
return !*v;
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
# else
template <VulkanRAIIHandleType T>
# endif
bool operator==( std::nullptr_t, T const & v ) VULKAN_HPP_NOEXCEPT
{
return !*v;
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
# else
template <VulkanRAIIHandleType T>
# endif
bool operator!=( T const & v, std::nullptr_t ) VULKAN_HPP_NOEXCEPT
{
return *v;
}
# if VULKAN_HPP_CPP_VERSION < 20
template <typename T, typename std::enable_if<isVulkanRAIIHandleType<T>::value, bool>::type = 0>
# else
template <VulkanRAIIHandleType T>
# endif
bool operator!=( std::nullptr_t, T const & v ) VULKAN_HPP_NOEXCEPT
{
return *v;
third_party/vulkan/vulkan_static_assertions.hpp
Vendored
+10
View File
@@ -10588,4 +10588,14 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV>::value,
"PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV is not nothrow_move_constructible!" );
//=== VK_NV_private_data_base_handle ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV ) ==
sizeof( VkPhysicalDevicePrivateDataBaseHandleFeaturesNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataBaseHandleFeaturesNV>::value,
"PhysicalDevicePrivateDataBaseHandleFeaturesNV is not nothrow_move_constructible!" );
#endif
third_party/vulkan/vulkan_structs.hpp
Vendored
+125
View File
@@ -56665,6 +56665,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
using Type = DeviceOrHostAddressConstAMDX;
};
# endif
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
// wrapper struct for struct VkDevicePipelineBinaryInternalCacheControlKHR, see
@@ -138091,6 +138092,130 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
};
// wrapper struct for struct VkPhysicalDevicePrivateDataBaseHandleFeaturesNV, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrivateDataBaseHandleFeaturesNV.html
struct PhysicalDevicePrivateDataBaseHandleFeaturesNV
{
using NativeType = VkPhysicalDevicePrivateDataBaseHandleFeaturesNV;
static bool const allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePrivateDataBaseHandleFeaturesNV;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDevicePrivateDataBaseHandleFeaturesNV( Bool32 privateDataBaseHandle_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, privateDataBaseHandle{ privateDataBaseHandle_ }
{
}
VULKAN_HPP_CONSTEXPR
PhysicalDevicePrivateDataBaseHandleFeaturesNV( PhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDevicePrivateDataBaseHandleFeaturesNV( VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDevicePrivateDataBaseHandleFeaturesNV( *reinterpret_cast<PhysicalDevicePrivateDataBaseHandleFeaturesNV const *>( &rhs ) )
{
}
PhysicalDevicePrivateDataBaseHandleFeaturesNV & operator=( PhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDevicePrivateDataBaseHandleFeaturesNV & operator=( VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDevicePrivateDataBaseHandleFeaturesNV const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataBaseHandleFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataBaseHandleFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return std::move( *this );
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataBaseHandleFeaturesNV & setPrivateDataBaseHandle( Bool32 privateDataBaseHandle_ ) & VULKAN_HPP_NOEXCEPT
{
privateDataBaseHandle = privateDataBaseHandle_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataBaseHandleFeaturesNV && setPrivateDataBaseHandle( Bool32 privateDataBaseHandle_ ) && VULKAN_HPP_NOEXCEPT
{
privateDataBaseHandle = privateDataBaseHandle_;
return std::move( *this );
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const *>( this );
}
operator VkPhysicalDevicePrivateDataBaseHandleFeaturesNV &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV *>( this );
}
operator VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV const *>( this );
}
operator VkPhysicalDevicePrivateDataBaseHandleFeaturesNV *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, void * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, privateDataBaseHandle );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDevicePrivateDataBaseHandleFeaturesNV const & ) const = default;
#else
bool operator==( PhysicalDevicePrivateDataBaseHandleFeaturesNV 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 ) && ( privateDataBaseHandle == rhs.privateDataBaseHandle );
# endif
}
bool operator!=( PhysicalDevicePrivateDataBaseHandleFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::ePhysicalDevicePrivateDataBaseHandleFeaturesNV;
void * pNext = {};
Bool32 privateDataBaseHandle = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDevicePrivateDataBaseHandleFeaturesNV>
{
using Type = PhysicalDevicePrivateDataBaseHandleFeaturesNV;
};
#endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDevicePrivateDataBaseHandleFeaturesNV>
{
using Type = PhysicalDevicePrivateDataBaseHandleFeaturesNV;
};
// wrapper struct for struct VkPhysicalDevicePrivateDataFeatures, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrivateDataFeatures.html
struct PhysicalDevicePrivateDataFeatures
third_party/vulkan/vulkan_to_string.hpp
Vendored
+17 -4
View File
@@ -1650,9 +1650,17 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
return result;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlags )
VULKAN_HPP_INLINE std::string to_string( PrivateDataSlotCreateFlags value )
{
return "{}";
std::string result = "{";
if ( value & PrivateDataSlotCreateFlagBits::eBaseObjectHandleNV )
result += " BaseObjectHandleNV |";
if ( result.size() > 1 )
result.back() = '}';
else
result = "{}";
return result;
}
VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags2 value )
@@ -6202,6 +6210,7 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceImageTilingControlFeaturesEXT : return "PhysicalDeviceImageTilingControlFeaturesEXT";
case StructureType::eImageTilingControlCreateInfoEXT : return "ImageTilingControlCreateInfoEXT";
case StructureType::ePhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV: return "PhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV";
case StructureType::ePhysicalDevicePrivateDataBaseHandleFeaturesNV : return "PhysicalDevicePrivateDataBaseHandleFeaturesNV";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@@ -8347,9 +8356,13 @@ VULKAN_HPP_EXPORT namespace VULKAN_HPP_NAMESPACE
}
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlagBits )
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlagBits value )
{
return "(void)";
switch ( value )
{
case PrivateDataSlotCreateFlagBits::eBaseObjectHandleNV: return "BaseObjectHandleNV";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineStageFlagBits2 value )
third_party/vulkan/vulkan_video.cppm
Vendored
+1
View File
@@ -51,6 +51,7 @@ module;
export module vulkan_video;
import std;
import vulkan;
#if defined( __clang__ )