kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-06-13 11:24:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

update dependencies (#71)

Browse Source 
Automated changes by
[create-pull-request](https://github.com/peter-evans/create-pull-request)
GitHub action
This commit is contained in:
kbz_8
2024-07-01 22:07:45 +02:00
committed by GitHub
parent d5512b72fa f8e1cd4a66
commit e30a243452
10 changed files with 1754 additions and 996 deletions
Download Patch File Download Diff File Expand all files Collapse all files
third_party/vulkan/vulkan.cppm
Vendored
+14
View File
@@ -844,6 +844,9 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::TimeDomainEXT; using VULKAN_HPP_NAMESPACE::TimeDomainEXT;
using VULKAN_HPP_NAMESPACE::TimeDomainKHR; using VULKAN_HPP_NAMESPACE::TimeDomainKHR;
//=== VK_KHR_maintenance7 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiKHR;
//========================= //=========================
//=== Index Type Traits === //=== Index Type Traits ===
//========================= //=========================
@@ -2506,6 +2509,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName; using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName;
using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion; using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion;
//=== VK_KHR_maintenance7 ===
using VULKAN_HPP_NAMESPACE::KHRMaintenance7ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRMaintenance7SpecVersion;
//=== VK_NV_shader_atomic_float16_vector === //=== VK_NV_shader_atomic_float16_vector ===
using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName; using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName;
using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion; using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion;
@@ -4369,6 +4376,13 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_shader_relaxed_extended_instruction === //=== VK_KHR_shader_relaxed_extended_instruction ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
//=== VK_KHR_maintenance7 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR;
//=== VK_NV_shader_atomic_float16_vector === //=== VK_NV_shader_atomic_float16_vector ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
third_party/vulkan/vulkan.hpp
Vendored
+71 -73
View File
@@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span> # include <span>
#endif #endif
static_assert( VK_HEADER_VERSION == 288, "Wrong VK_HEADER_VERSION!" ); static_assert( VK_HEADER_VERSION == 289, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header // <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x) // this results in major(x) being resolved to gnu_dev_major(x)
@@ -149,7 +149,7 @@ namespace VULKAN_HPP_NAMESPACE
private: private:
VULKAN_HPP_CONSTEXPR_14 void copy( char const * data, size_t len ) VULKAN_HPP_NOEXCEPT VULKAN_HPP_CONSTEXPR_14 void copy( char const * data, size_t len ) VULKAN_HPP_NOEXCEPT
{ {
size_t n = std::min( N - 1, len ); size_t n = ( std::min )( N - 1, len );
for ( size_t i = 0; i < n; ++i ) for ( size_t i = 0; i < n; ++i )
{ {
( *this )[i] = data[i]; ( *this )[i] = data[i];
@@ -388,38 +388,19 @@ namespace VULKAN_HPP_NAMESPACE
{ {
} }
ArrayProxyNoTemporaries( T & value ) VULKAN_HPP_NOEXCEPT 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
: m_count( 1 ) : m_count( 1 )
, m_ptr( &value ) , m_ptr( &value )
{ {
} }
template <typename V>
ArrayProxyNoTemporaries( V && value ) = delete;
template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT
: m_count( 1 )
, m_ptr( &value )
{
}
template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( typename std::remove_const<T>::type && value ) = delete;
ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
: m_count( count ) : m_count( count )
, m_ptr( ptr ) , m_ptr( ptr )
{ {
} }
template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT
: m_count( count )
, m_ptr( ptr )
{
}
template <std::size_t C> template <std::size_t C>
ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
: m_count( C ) : m_count( C )
@@ -430,62 +411,29 @@ namespace VULKAN_HPP_NAMESPACE
template <std::size_t C> template <std::size_t C>
ArrayProxyNoTemporaries( T ( &&ptr )[C] ) = delete; ArrayProxyNoTemporaries( T ( &&ptr )[C] ) = delete;
template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> // Any l-value reference with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
ArrayProxyNoTemporaries( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
: m_count( C )
, m_ptr( ptr )
{
}
template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( typename std::remove_const<T>::type ( &&ptr )[C] ) = delete;
ArrayProxyNoTemporaries( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( list.size() ) )
, m_ptr( list.begin() )
{
}
ArrayProxyNoTemporaries( std::initializer_list<T> const && list ) = delete;
template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( 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() )
{
}
template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const && list ) = delete;
ArrayProxyNoTemporaries( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( list.size() ) )
, m_ptr( list.begin() )
{
}
ArrayProxyNoTemporaries( std::initializer_list<T> && list ) = delete;
template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( list.size() ) )
, m_ptr( list.begin() )
{
}
template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> && list ) = delete;
// Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
template <typename V, template <typename V,
typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value && 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>::type * = nullptr> std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
ArrayProxyNoTemporaries( V & v ) VULKAN_HPP_NOEXCEPT std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value,
int>::type = 0>
ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( v.size() ) ) : m_count( static_cast<uint32_t>( v.size() ) )
, m_ptr( v.data() ) , m_ptr( v.data() )
{ {
} }
// Any l-value reference with a .begin() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
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>
ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
: m_count( static_cast<uint32_t>( v.size() ) )
, m_ptr( v.begin() )
{
}
const T * begin() const VULKAN_HPP_NOEXCEPT const T * begin() const VULKAN_HPP_NOEXCEPT
{ {
return m_ptr; return m_ptr;
@@ -8691,6 +8639,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION;
//=== VK_KHR_maintenance7 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7ExtensionName = VK_KHR_MAINTENANCE_7_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7SpecVersion = VK_KHR_MAINTENANCE_7_SPEC_VERSION;
//=== VK_NV_shader_atomic_float16_vector === //=== VK_NV_shader_atomic_float16_vector ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION; VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION;
@@ -16722,6 +16674,52 @@ namespace VULKAN_HPP_NAMESPACE
}; };
}; };
//=== VK_KHR_maintenance7 ===
template <>
struct StructExtends<PhysicalDeviceMaintenance7FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance7FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance7PropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLayeredApiPropertiesListKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceLayeredApiVulkanPropertiesKHR, PhysicalDeviceLayeredApiPropertiesKHR>
{
enum
{
value = true
};
};
//=== VK_NV_shader_atomic_float16_vector === //=== VK_NV_shader_atomic_float16_vector ===
template <> template <>
struct StructExtends<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, PhysicalDeviceFeatures2> struct StructExtends<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, PhysicalDeviceFeatures2>
third_party/vulkan/vulkan_core.h
Vendored
+67 -4
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 #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 // Version of this file
#define VK_HEADER_VERSION 288 #define VK_HEADER_VERSION 289
// Complete version of this file // Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@@ -1113,6 +1113,11 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR = 1000562000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR = 1000562001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR = 1000562002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR = 1000562003,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR = 1000562004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000,
@@ -2175,7 +2180,8 @@ typedef enum VkIndexType {
typedef enum VkSubpassContents { typedef enum VkSubpassContents {
VK_SUBPASS_CONTENTS_INLINE = 0, VK_SUBPASS_CONTENTS_INLINE = 0,
VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = 1000451000, VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR = 1000451000,
VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR,
VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
} VkSubpassContents; } VkSubpassContents;
@@ -6718,11 +6724,12 @@ typedef enum VkRenderingFlagBits {
VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001,
VK_RENDERING_SUSPENDING_BIT = 0x00000002, VK_RENDERING_SUSPENDING_BIT = 0x00000002,
VK_RENDERING_RESUMING_BIT = 0x00000004, VK_RENDERING_RESUMING_BIT = 0x00000004,
VK_RENDERING_CONTENTS_INLINE_BIT_EXT = 0x00000010,
VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008, VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008,
VK_RENDERING_CONTENTS_INLINE_BIT_KHR = 0x00000010,
VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT,
VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT, VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT,
VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT, VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT,
VK_RENDERING_CONTENTS_INLINE_BIT_EXT = VK_RENDERING_CONTENTS_INLINE_BIT_KHR,
VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkRenderingFlagBits; } VkRenderingFlagBits;
typedef VkFlags VkRenderingFlags; typedef VkFlags VkRenderingFlags;
@@ -11722,6 +11729,62 @@ typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
// VK_KHR_maintenance7 is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_maintenance7 1
#define VK_KHR_MAINTENANCE_7_SPEC_VERSION 1
#define VK_KHR_MAINTENANCE_7_EXTENSION_NAME "VK_KHR_maintenance7"
typedef enum VkPhysicalDeviceLayeredApiKHR {
VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR = 0,
VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR = 1,
VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR = 2,
VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR = 3,
VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR = 4,
VK_PHYSICAL_DEVICE_LAYERED_API_MAX_ENUM_KHR = 0x7FFFFFFF
} VkPhysicalDeviceLayeredApiKHR;
typedef struct VkPhysicalDeviceMaintenance7FeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 maintenance7;
} VkPhysicalDeviceMaintenance7FeaturesKHR;
typedef struct VkPhysicalDeviceMaintenance7PropertiesKHR {
VkStructureType sType;
void* pNext;
VkBool32 robustFragmentShadingRateAttachmentAccess;
VkBool32 separateDepthStencilAttachmentAccess;
uint32_t maxDescriptorSetTotalUniformBuffersDynamic;
uint32_t maxDescriptorSetTotalStorageBuffersDynamic;
uint32_t maxDescriptorSetTotalBuffersDynamic;
uint32_t maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic;
uint32_t maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic;
uint32_t maxDescriptorSetUpdateAfterBindTotalBuffersDynamic;
} VkPhysicalDeviceMaintenance7PropertiesKHR;
typedef struct VkPhysicalDeviceLayeredApiPropertiesKHR {
VkStructureType sType;
void* pNext;
uint32_t vendorID;
uint32_t deviceID;
VkPhysicalDeviceLayeredApiKHR layeredAPI;
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
} VkPhysicalDeviceLayeredApiPropertiesKHR;
typedef struct VkPhysicalDeviceLayeredApiPropertiesListKHR {
VkStructureType sType;
void* pNext;
uint32_t layeredApiCount;
VkPhysicalDeviceLayeredApiPropertiesKHR* pLayeredApis;
} VkPhysicalDeviceLayeredApiPropertiesListKHR;
typedef struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR {
VkStructureType sType;
void* pNext;
VkPhysicalDeviceProperties2 properties;
} VkPhysicalDeviceLayeredApiVulkanPropertiesKHR;
// VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_debug_report 1 #define VK_EXT_debug_report 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
@@ -17714,7 +17777,7 @@ typedef struct VkRenderPassStripeSubmitInfoARM {
// VK_QCOM_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls. // VK_QCOM_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls.
#define VK_QCOM_fragment_density_map_offset 1 #define VK_QCOM_fragment_density_map_offset 1
#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 2
#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset" #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset"
typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
VkStructureType sType; VkStructureType sType;
third_party/vulkan/vulkan_enums.hpp
Vendored
+132 -45
View File
@@ -1419,6 +1419,11 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV,
ePhysicalDeviceRawAccessChainsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, ePhysicalDeviceRawAccessChainsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV,
ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR,
ePhysicalDeviceMaintenance7FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR,
ePhysicalDeviceMaintenance7PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR,
ePhysicalDeviceLayeredApiPropertiesListKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR,
ePhysicalDeviceLayeredApiPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR,
ePhysicalDeviceLayeredApiVulkanPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR,
ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV, ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV,
ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT, ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT,
ePhysicalDeviceRayTracingValidationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV, ePhysicalDeviceRayTracingValidationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV,
@@ -3573,6 +3578,51 @@ namespace VULKAN_HPP_NAMESPACE
eUint8EXT = VK_INDEX_TYPE_UINT8_EXT eUint8EXT = VK_INDEX_TYPE_UINT8_EXT
}; };
//=========================
//=== Index Type Traits ===
//=========================
template <typename T>
struct IndexTypeValue
{
};
template <>
struct IndexTypeValue<uint16_t>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint16;
};
template <>
struct CppType<IndexType, IndexType::eUint16>
{
using Type = uint16_t;
};
template <>
struct IndexTypeValue<uint32_t>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint32;
};
template <>
struct CppType<IndexType, IndexType::eUint32>
{
using Type = uint32_t;
};
template <>
struct IndexTypeValue<uint8_t>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8KHR;
};
template <>
struct CppType<IndexType, IndexType::eUint8KHR>
{
using Type = uint8_t;
};
enum class StencilFaceFlagBits : VkStencilFaceFlags enum class StencilFaceFlagBits : VkStencilFaceFlags
{ {
eFront = VK_STENCIL_FACE_FRONT_BIT, eFront = VK_STENCIL_FACE_FRONT_BIT,
@@ -3595,6 +3645,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
eInline = VK_SUBPASS_CONTENTS_INLINE, eInline = VK_SUBPASS_CONTENTS_INLINE,
eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
eInlineAndSecondaryCommandBuffersKHR = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR,
eInlineAndSecondaryCommandBuffersEXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT eInlineAndSecondaryCommandBuffersEXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT
}; };
@@ -4284,8 +4335,9 @@ namespace VULKAN_HPP_NAMESPACE
eContentsSecondaryCommandBuffers = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, eContentsSecondaryCommandBuffers = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT,
eSuspending = VK_RENDERING_SUSPENDING_BIT, eSuspending = VK_RENDERING_SUSPENDING_BIT,
eResuming = VK_RENDERING_RESUMING_BIT, eResuming = VK_RENDERING_RESUMING_BIT,
eContentsInlineEXT = VK_RENDERING_CONTENTS_INLINE_BIT_EXT, eEnableLegacyDitheringEXT = VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT,
eEnableLegacyDitheringEXT = VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT eContentsInlineKHR = VK_RENDERING_CONTENTS_INLINE_BIT_KHR,
eContentsInlineEXT = VK_RENDERING_CONTENTS_INLINE_BIT_EXT
}; };
using RenderingFlagBitsKHR = RenderingFlagBits; using RenderingFlagBitsKHR = RenderingFlagBits;
@@ -4297,8 +4349,8 @@ namespace VULKAN_HPP_NAMESPACE
{ {
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingFlags allFlags = RenderingFlagBits::eContentsSecondaryCommandBuffers | RenderingFlagBits::eSuspending | static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingFlags allFlags = RenderingFlagBits::eContentsSecondaryCommandBuffers | RenderingFlagBits::eSuspending |
RenderingFlagBits::eResuming | RenderingFlagBits::eContentsInlineEXT | RenderingFlagBits::eResuming | RenderingFlagBits::eEnableLegacyDitheringEXT |
RenderingFlagBits::eEnableLegacyDitheringEXT; RenderingFlagBits::eContentsInlineKHR;
}; };
enum class FormatFeatureFlagBits2 : VkFormatFeatureFlags2 enum class FormatFeatureFlagBits2 : VkFormatFeatureFlags2
@@ -7091,6 +7143,75 @@ namespace VULKAN_HPP_NAMESPACE
eString = VK_LAYER_SETTING_TYPE_STRING_EXT eString = VK_LAYER_SETTING_TYPE_STRING_EXT
}; };
//=================================
//=== Layer Setting Type Traits ===
//=================================
template <>
struct CppType<LayerSettingTypeEXT, LayerSettingTypeEXT::eBool32>
{
using Type = vk::Bool32;
};
template <>
struct CppType<LayerSettingTypeEXT, LayerSettingTypeEXT::eInt32>
{
using Type = int32_t;
};
template <>
struct CppType<LayerSettingTypeEXT, LayerSettingTypeEXT::eInt64>
{
using Type = int64_t;
};
template <>
struct CppType<LayerSettingTypeEXT, LayerSettingTypeEXT::eUint32>
{
using Type = uint32_t;
};
template <>
struct CppType<LayerSettingTypeEXT, LayerSettingTypeEXT::eUint64>
{
using Type = uint64_t;
};
template <>
struct CppType<LayerSettingTypeEXT, LayerSettingTypeEXT::eFloat32>
{
using Type = float;
};
template <>
struct CppType<LayerSettingTypeEXT, LayerSettingTypeEXT::eFloat64>
{
using Type = double;
};
template <>
struct CppType<LayerSettingTypeEXT, LayerSettingTypeEXT::eString>
{
using Type = char *;
};
template <typename T>
bool isSameType( LayerSettingTypeEXT layerSettingType )
{
switch ( layerSettingType )
{
case LayerSettingTypeEXT::eBool32: return std::is_same<T, VULKAN_HPP_NAMESPACE::Bool32>::value;
case LayerSettingTypeEXT::eInt32: return std::is_same<T, int32_t>::value;
case LayerSettingTypeEXT::eInt64: return std::is_same<T, int64_t>::value;
case LayerSettingTypeEXT::eUint32: return std::is_same<T, uint32_t>::value;
case LayerSettingTypeEXT::eUint64: return std::is_same<T, uint64_t>::value;
case LayerSettingTypeEXT::eFloat32: return std::is_same<T, float>::value;
case LayerSettingTypeEXT::eFloat64: return std::is_same<T, double>::value;
case LayerSettingTypeEXT::eString: return std::is_same<T, char *>::value;
default: return false;
}
}
//=== VK_NV_low_latency2 === //=== VK_NV_low_latency2 ===
enum class LatencyMarkerNV enum class LatencyMarkerNV
@@ -7190,49 +7311,15 @@ namespace VULKAN_HPP_NAMESPACE
}; };
using TimeDomainEXT = TimeDomainKHR; using TimeDomainEXT = TimeDomainKHR;
//========================= //=== VK_KHR_maintenance7 ===
//=== Index Type Traits ===
//=========================
template <typename T> enum class PhysicalDeviceLayeredApiKHR
struct IndexTypeValue
{ {
}; eVulkan = VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR,
eD3D12 = VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR,
template <> eMetal = VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR,
struct IndexTypeValue<uint16_t> eOpengl = VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR,
{ eOpengles = VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR
static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint16;
};
template <>
struct CppType<IndexType, IndexType::eUint16>
{
using Type = uint16_t;
};
template <>
struct IndexTypeValue<uint32_t>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint32;
};
template <>
struct CppType<IndexType, IndexType::eUint32>
{
using Type = uint32_t;
};
template <>
struct IndexTypeValue<uint8_t>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8KHR;
};
template <>
struct CppType<IndexType, IndexType::eUint8KHR>
{
using Type = uint8_t;
}; };
//=========================================================== //===========================================================
third_party/vulkan/vulkan_extension_inspection.hpp
Vendored
+5 -3
View File
@@ -437,6 +437,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_NV_descriptor_pool_overallocation", "VK_NV_descriptor_pool_overallocation",
"VK_NV_raw_access_chains", "VK_NV_raw_access_chains",
"VK_KHR_shader_relaxed_extended_instruction", "VK_KHR_shader_relaxed_extended_instruction",
"VK_KHR_maintenance7",
"VK_NV_shader_atomic_float16_vector", "VK_NV_shader_atomic_float16_vector",
"VK_EXT_shader_replicated_composites", "VK_EXT_shader_replicated_composites",
"VK_NV_ray_tracing_validation", "VK_NV_ray_tracing_validation",
@@ -2316,6 +2317,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_VERSION_1_1", { {} } } } }, { "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } }, { "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } }, { "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_MESA_image_alignment_control", { "VK_MESA_image_alignment_control",
{ { "VK_VERSION_1_0", { { "VK_VERSION_1_0",
{ { { {
@@ -3085,9 +3087,9 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) || || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_raw_access_chains" ) ||
( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_KHR_maintenance7" ) ||
( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) ||
( extension == "VK_MESA_image_alignment_control" ); ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_MESA_image_alignment_control" );
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
third_party/vulkan/vulkan_handles.hpp
Vendored
+7
View File
@@ -1830,6 +1830,13 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_shader_relaxed_extended_instruction === //=== VK_KHR_shader_relaxed_extended_instruction ===
struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
//=== VK_KHR_maintenance7 ===
struct PhysicalDeviceMaintenance7FeaturesKHR;
struct PhysicalDeviceMaintenance7PropertiesKHR;
struct PhysicalDeviceLayeredApiPropertiesListKHR;
struct PhysicalDeviceLayeredApiPropertiesKHR;
struct PhysicalDeviceLayeredApiVulkanPropertiesKHR;
//=== VK_NV_shader_atomic_float16_vector === //=== VK_NV_shader_atomic_float16_vector ===
struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
third_party/vulkan/vulkan_hash.hpp
Vendored
+175 -63
View File
@@ -9426,29 +9426,36 @@ namespace std
}; };
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR>
{ {
std::size_t std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR const & physicalDeviceLayeredApiPropertiesKHR ) const VULKAN_HPP_NOEXCEPT
{ {
std::size_t seed = 0; std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.vendorID );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceID );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.layeredAPI );
for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceName[i] );
}
return seed; return seed;
} }
}; };
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR>
{ {
std::size_t std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR const & physicalDeviceLayeredApiPropertiesListKHR ) const VULKAN_HPP_NOEXCEPT
{ {
std::size_t seed = 0; std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering ); VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.layeredApiCount );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pLayeredApis );
return seed; return seed;
} }
}; };
@@ -9615,6 +9622,129 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType );
for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] );
}
for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] );
}
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR const & physicalDeviceLayeredApiVulkanPropertiesKHR ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.properties );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT>
{
std::size_t operator()(
VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & physicalDeviceLegacyVertexAttributesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.legacyVertexAttributes );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & physicalDeviceLegacyVertexAttributesPropertiesEXT )
const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.nativeUnalignedPerformance );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR>
{ {
@@ -9765,6 +9895,41 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR const & physicalDeviceMaintenance7FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.maintenance7 );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR const & physicalDeviceMaintenance7PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.robustFragmentShadingRateAttachmentAccess );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.separateDepthStencilAttachmentAccess );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalUniformBuffersDynamic );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalStorageBuffersDynamic );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalBuffersDynamic );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT>
{ {
@@ -10567,59 +10732,6 @@ namespace std
} }
}; };
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType );
for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] );
}
for ( size_t i = 0; i < VK_UUID_SIZE; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] );
}
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties );
return seed;
}
};
template <> template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures>
{ {
third_party/vulkan/vulkan_static_assertions.hpp
Vendored
+38
View File
@@ -7571,6 +7571,44 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>::value, VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>::value,
"PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR is not nothrow_move_constructible!" ); "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR is not nothrow_move_constructible!" );
//=== VK_KHR_maintenance7 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance7FeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR>::value,
"PhysicalDeviceMaintenance7FeaturesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR ) == sizeof( VkPhysicalDeviceMaintenance7PropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR>::value,
"PhysicalDeviceMaintenance7PropertiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR ) == sizeof( VkPhysicalDeviceLayeredApiPropertiesListKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR>::value,
"PhysicalDeviceLayeredApiPropertiesListKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR ) == sizeof( VkPhysicalDeviceLayeredApiPropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR>::value,
"PhysicalDeviceLayeredApiPropertiesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR ) ==
sizeof( VkPhysicalDeviceLayeredApiVulkanPropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR>::value,
"PhysicalDeviceLayeredApiVulkanPropertiesKHR is not nothrow_move_constructible!" );
//=== VK_NV_shader_atomic_float16_vector === //=== VK_NV_shader_atomic_float16_vector ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ) == VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ) ==
third_party/vulkan/vulkan_structs.hpp
Vendored
+1216 -799
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_to_string.hpp
Vendored
+24 -4
View File
@@ -1747,10 +1747,10 @@ namespace VULKAN_HPP_NAMESPACE
result += "Suspending | "; result += "Suspending | ";
if ( value & RenderingFlagBits::eResuming ) if ( value & RenderingFlagBits::eResuming )
result += "Resuming | "; result += "Resuming | ";
if ( value & RenderingFlagBits::eContentsInlineEXT )
result += "ContentsInlineEXT | ";
if ( value & RenderingFlagBits::eEnableLegacyDitheringEXT ) if ( value & RenderingFlagBits::eEnableLegacyDitheringEXT )
result += "EnableLegacyDitheringEXT | "; result += "EnableLegacyDitheringEXT | ";
if ( value & RenderingFlagBits::eContentsInlineKHR )
result += "ContentsInlineKHR | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@@ -4553,6 +4553,11 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV"; case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV"; case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV";
case StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR: return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"; case StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR: return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR";
case StructureType::ePhysicalDeviceMaintenance7FeaturesKHR: return "PhysicalDeviceMaintenance7FeaturesKHR";
case StructureType::ePhysicalDeviceMaintenance7PropertiesKHR: return "PhysicalDeviceMaintenance7PropertiesKHR";
case StructureType::ePhysicalDeviceLayeredApiPropertiesListKHR: return "PhysicalDeviceLayeredApiPropertiesListKHR";
case StructureType::ePhysicalDeviceLayeredApiPropertiesKHR: return "PhysicalDeviceLayeredApiPropertiesKHR";
case StructureType::ePhysicalDeviceLayeredApiVulkanPropertiesKHR: return "PhysicalDeviceLayeredApiVulkanPropertiesKHR";
case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV: return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"; case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV: return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV";
case StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT: return "PhysicalDeviceShaderReplicatedCompositesFeaturesEXT"; case StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT: return "PhysicalDeviceShaderReplicatedCompositesFeaturesEXT";
case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV: return "PhysicalDeviceRayTracingValidationFeaturesNV"; case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV: return "PhysicalDeviceRayTracingValidationFeaturesNV";
@@ -6250,7 +6255,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
case SubpassContents::eInline: return "Inline"; case SubpassContents::eInline: return "Inline";
case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers"; case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers";
case SubpassContents::eInlineAndSecondaryCommandBuffersEXT: return "InlineAndSecondaryCommandBuffersEXT"; case SubpassContents::eInlineAndSecondaryCommandBuffersKHR: return "InlineAndSecondaryCommandBuffersKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -6734,8 +6739,8 @@ namespace VULKAN_HPP_NAMESPACE
case RenderingFlagBits::eContentsSecondaryCommandBuffers: return "ContentsSecondaryCommandBuffers"; case RenderingFlagBits::eContentsSecondaryCommandBuffers: return "ContentsSecondaryCommandBuffers";
case RenderingFlagBits::eSuspending: return "Suspending"; case RenderingFlagBits::eSuspending: return "Suspending";
case RenderingFlagBits::eResuming: return "Resuming"; case RenderingFlagBits::eResuming: return "Resuming";
case RenderingFlagBits::eContentsInlineEXT: return "ContentsInlineEXT";
case RenderingFlagBits::eEnableLegacyDitheringEXT: return "EnableLegacyDitheringEXT"; case RenderingFlagBits::eEnableLegacyDitheringEXT: return "EnableLegacyDitheringEXT";
case RenderingFlagBits::eContentsInlineKHR: return "ContentsInlineKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@@ -9081,5 +9086,20 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
//=== VK_KHR_maintenance7 ===
VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceLayeredApiKHR value )
{
switch ( value )
{
case PhysicalDeviceLayeredApiKHR::eVulkan: return "Vulkan";
case PhysicalDeviceLayeredApiKHR::eD3D12: return "D3D12";
case PhysicalDeviceLayeredApiKHR::eMetal: return "Metal";
case PhysicalDeviceLayeredApiKHR::eOpengl: return "Opengl";
case PhysicalDeviceLayeredApiKHR::eOpengles: return "Opengles";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
} // namespace VULKAN_HPP_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE
#endif #endif