From da48596af43e43996a2cbc1bf01b6eebe9aff9a5 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sun, 11 May 2025 00:45:47 +0000 Subject: [PATCH] [BOT] update dependencies --- third_party/vulkan/vulkan.cppm | 16 +- third_party/vulkan/vulkan.hpp | 85 ++++--- third_party/vulkan/vulkan_core.h | 65 +++-- third_party/vulkan/vulkan_enums.hpp | 26 +- .../vulkan/vulkan_extension_inspection.hpp | 29 ++- third_party/vulkan/vulkan_format_traits.hpp | 129 +++++++++- third_party/vulkan/vulkan_funcs.hpp | 24 +- third_party/vulkan/vulkan_handles.hpp | 21 +- third_party/vulkan/vulkan_hash.hpp | 41 +++- third_party/vulkan/vulkan_raii.hpp | 33 +-- .../vulkan/vulkan_static_assertions.hpp | 42 ++-- third_party/vulkan/vulkan_structs.hpp | 228 +++++++++++++----- third_party/vulkan/vulkan_to_string.hpp | 9 +- 13 files changed, 540 insertions(+), 208 deletions(-) diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm index cca3fe1..5b1da00 100644 --- a/third_party/vulkan/vulkan.cppm +++ b/third_party/vulkan/vulkan.cppm @@ -42,11 +42,16 @@ export namespace VULKAN_HPP_NAMESPACE { using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase; using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic; +#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER ) +# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 + using VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic; +# endif +#endif #if !defined( VK_NO_PROTOTYPES ) using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic; using VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic; #endif /*VK_NO_PROTOTYPES*/ - } // namespace detail + } // namespace detail using VULKAN_HPP_NAMESPACE::operator&; using VULKAN_HPP_NAMESPACE::operator|; @@ -5229,7 +5234,7 @@ export namespace VULKAN_HPP_NAMESPACE namespace detail { using VULKAN_HPP_NAMESPACE::detail::DynamicLoader; - } // namespace detail + } // namespace detail #endif /*VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL*/ //===================== @@ -5245,6 +5250,11 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::componentPlaneIndex; using VULKAN_HPP_NAMESPACE::componentsAreCompressed; using VULKAN_HPP_NAMESPACE::compressionScheme; + using VULKAN_HPP_NAMESPACE::getDepthFormats; + using VULKAN_HPP_NAMESPACE::getDepthStencilFormats; + using VULKAN_HPP_NAMESPACE::getStencilFormats; + using VULKAN_HPP_NAMESPACE::hasDepthComponent; + using VULKAN_HPP_NAMESPACE::hasStencilComponent; using VULKAN_HPP_NAMESPACE::isCompressed; using VULKAN_HPP_NAMESPACE::packed; using VULKAN_HPP_NAMESPACE::planeCompatibleFormat; @@ -8626,4 +8636,4 @@ export namespace std // This VkFlags type is used as part of a bitfield in some structure. // As it can't be mimicked by vk-data types, we need to export just that!! -export using ::VkGeometryInstanceFlagsKHR; \ No newline at end of file +export using ::VkGeometryInstanceFlagsKHR; diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index 1dc3da0..03f0d9a 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -55,7 +55,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # endif #endif -static_assert( VK_HEADER_VERSION == 313, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 315, "Wrong VK_HEADER_VERSION!" ); // includes through some other header // this results in major(x) being resolved to gnu_dev_major(x) @@ -9032,6 +9032,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessExtensionName = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION; + //=== VK_KHR_robustness2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2ExtensionName = VK_KHR_ROBUSTNESS_2_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2SpecVersion = VK_KHR_ROBUSTNESS_2_SPEC_VERSION; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_present_metering === VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringExtensionName = VK_NV_PRESENT_METERING_EXTENSION_NAME; @@ -9042,6 +9046,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION; + //=== VK_EXT_zero_initialize_device_memory === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemoryExtensionName = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemorySpecVersion = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION; + } // namespace VULKAN_HPP_NAMESPACE // clang-format off @@ -13890,34 +13898,6 @@ namespace VULKAN_HPP_NAMESPACE }; }; - //=== VK_EXT_robustness2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - //=== VK_EXT_custom_border_color === template <> struct StructExtends @@ -18181,6 +18161,34 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_KHR_robustness2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_present_metering === template <> @@ -18257,6 +18265,25 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_EXT_zero_initialize_device_memory === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + #endif // VULKAN_HPP_DISABLE_ENHANCED_MODE namespace detail diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h index b57b368..4ed3283 100644 --- a/third_party/vulkan/vulkan_core.h +++ b/third_party/vulkan/vulkan_core.h @@ -69,7 +69,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 313 +#define VK_HEADER_VERSION 315 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -839,8 +839,6 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, @@ -1250,6 +1248,8 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001, #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000, #endif @@ -1260,6 +1260,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001, VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002, VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = 1000619003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000, 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 deprecated alias @@ -1430,6 +1431,8 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, @@ -1538,6 +1541,7 @@ typedef enum VkImageLayout { VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002, VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR = 1000553000, + VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT = 1000620000, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, @@ -2570,7 +2574,7 @@ typedef enum VkImageUsageFlagBits { VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, - VK_IMAGE_USAGE_TILE_MEMORY_QCOM = 0x08000000, + VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM = 0x08000000, VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000, VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000, VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, @@ -2774,7 +2778,7 @@ typedef enum VkBufferUsageFlagBits { VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000, VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000, - VK_BUFFER_USAGE_TILE_MEMORY_QCOM = 0x08000000, + VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM = 0x08000000, VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, @@ -5228,6 +5232,7 @@ typedef enum VkMemoryAllocateFlagBits { VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004, + VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT = 0x00000008, VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, @@ -7974,7 +7979,7 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM = 0x08000000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM = 0x08000000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ULL; @@ -12964,6 +12969,27 @@ typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR { +// VK_KHR_robustness2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_robustness2 1 +#define VK_KHR_ROBUSTNESS_2_SPEC_VERSION 1 +#define VK_KHR_ROBUSTNESS_2_EXTENSION_NAME "VK_KHR_robustness2" +typedef struct VkPhysicalDeviceRobustness2FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 robustBufferAccess2; + VkBool32 robustImageAccess2; + VkBool32 nullDescriptor; +} VkPhysicalDeviceRobustness2FeaturesKHR; + +typedef struct VkPhysicalDeviceRobustness2PropertiesKHR { + VkStructureType sType; + void* pNext; + VkDeviceSize robustStorageBufferAccessSizeAlignment; + VkDeviceSize robustUniformBufferAccessSizeAlignment; +} VkPhysicalDeviceRobustness2PropertiesKHR; + + + // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) @@ -16945,20 +16971,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT( #define VK_EXT_robustness2 1 #define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1 #define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2" -typedef struct VkPhysicalDeviceRobustness2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 robustBufferAccess2; - VkBool32 robustImageAccess2; - VkBool32 nullDescriptor; -} VkPhysicalDeviceRobustness2FeaturesEXT; +typedef VkPhysicalDeviceRobustness2FeaturesKHR VkPhysicalDeviceRobustness2FeaturesEXT; -typedef struct VkPhysicalDeviceRobustness2PropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize robustStorageBufferAccessSizeAlignment; - VkDeviceSize robustUniformBufferAccessSizeAlignment; -} VkPhysicalDeviceRobustness2PropertiesEXT; +typedef VkPhysicalDeviceRobustness2PropertiesKHR VkPhysicalDeviceRobustness2PropertiesEXT; @@ -21631,6 +21646,18 @@ VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT( #endif +// VK_EXT_zero_initialize_device_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_zero_initialize_device_memory 1 +#define VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION 1 +#define VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME "VK_EXT_zero_initialize_device_memory" +typedef struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 zeroInitializeDeviceMemory; +} VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + + + // 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 diff --git a/third_party/vulkan/vulkan_enums.hpp b/third_party/vulkan/vulkan_enums.hpp index d315e45..4b0ebfa 100644 --- a/third_party/vulkan/vulkan_enums.hpp +++ b/third_party/vulkan/vulkan_enums.hpp @@ -1179,8 +1179,6 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceDeviceMemoryReportFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, eDeviceDeviceMemoryReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, eDeviceMemoryReportCallbackDataEXT = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT, - ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, - ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, eSamplerCustomBorderColorCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, ePhysicalDeviceCustomBorderColorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, ePhysicalDeviceCustomBorderColorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, @@ -1599,6 +1597,10 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceDepthClampZeroOneFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT, ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT, + ePhysicalDeviceRobustness2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, + ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, + ePhysicalDeviceRobustness2PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR, + ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, #if defined( VK_ENABLE_BETA_EXTENSIONS ) eSetPresentConfigNV = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV, ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV, @@ -1609,7 +1611,8 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM, eRenderPassFragmentDensityMapOffsetEndInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT, eSubpassFragmentDensityMapOffsetEndInfoQCOM = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM, - eRenderingEndInfoEXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT + eRenderingEndInfoEXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT, + ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT }; // wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html @@ -2175,7 +2178,7 @@ namespace VULKAN_HPP_NAMESPACE eInvocationMaskHUAWEI = VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI, eSampleWeightQCOM = VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM, eSampleBlockMatchQCOM = VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM, - eTileMemoryQCOM = VK_IMAGE_USAGE_TILE_MEMORY_QCOM, + eTileMemoryQCOM = VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM, eVideoEncodeQuantizationDeltaMapKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, eVideoEncodeEmphasisMapKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR }; @@ -2730,7 +2733,7 @@ namespace VULKAN_HPP_NAMESPACE ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, eMicromapStorageEXT = VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT, - eTileMemoryQCOM = VK_BUFFER_USAGE_TILE_MEMORY_QCOM + eTileMemoryQCOM = VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM }; // wrapper using for bitmask VkBufferUsageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlags.html @@ -2820,7 +2823,8 @@ namespace VULKAN_HPP_NAMESPACE eVideoEncodeSrcKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR, eVideoEncodeDpbKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR, eAttachmentFeedbackLoopOptimalEXT = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT, - eVideoEncodeQuantizationMapKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR + eVideoEncodeQuantizationMapKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR, + eZeroInitializedEXT = VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT }; // wrapper class for enum VkComponentSwizzle, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentSwizzle.html @@ -4126,7 +4130,8 @@ namespace VULKAN_HPP_NAMESPACE { eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, eDeviceAddress = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, - eDeviceAddressCaptureReplay = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT + eDeviceAddressCaptureReplay = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + eZeroInitializeEXT = VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT }; using MemoryAllocateFlagBitsKHR = MemoryAllocateFlagBits; @@ -4140,8 +4145,9 @@ namespace VULKAN_HPP_NAMESPACE { using WrappedType = VkMemoryAllocateFlagBits; static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryAllocateFlags allFlags = - MemoryAllocateFlagBits::eDeviceMask | MemoryAllocateFlagBits::eDeviceAddress | MemoryAllocateFlagBits::eDeviceAddressCaptureReplay; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryAllocateFlags allFlags = MemoryAllocateFlagBits::eDeviceMask | MemoryAllocateFlagBits::eDeviceAddress | + MemoryAllocateFlagBits::eDeviceAddressCaptureReplay | + MemoryAllocateFlagBits::eZeroInitializeEXT; }; enum class CommandPoolTrimFlagBits : VkCommandPoolTrimFlags @@ -5150,7 +5156,7 @@ namespace VULKAN_HPP_NAMESPACE ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, eMicromapStorageEXT = VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT, - eTileMemoryQCOM = VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM, + eTileMemoryQCOM = VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM, ePreprocessBufferEXT = VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT }; diff --git a/third_party/vulkan/vulkan_extension_inspection.hpp b/third_party/vulkan/vulkan_extension_inspection.hpp index 2f901e9..a2bd49c 100644 --- a/third_party/vulkan/vulkan_extension_inspection.hpp +++ b/third_party/vulkan/vulkan_extension_inspection.hpp @@ -477,10 +477,12 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_METAL_EXT*/ "VK_KHR_depth_clamp_zero_one", "VK_EXT_vertex_attribute_robustness", + "VK_KHR_robustness2", #if defined( VK_ENABLE_BETA_EXTENSIONS ) "VK_NV_present_metering", #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - "VK_EXT_fragment_density_map_offset" + "VK_EXT_fragment_density_map_offset", + "VK_EXT_zero_initialize_device_memory" }; return deviceExtensions; } @@ -2579,6 +2581,12 @@ namespace VULKAN_HPP_NAMESPACE "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_robustness2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, { "VK_EXT_fragment_density_map_offset", { { "VK_VERSION_1_0", { { @@ -2601,7 +2609,13 @@ namespace VULKAN_HPP_NAMESPACE { "VK_VERSION_1_3", { { "VK_EXT_fragment_density_map", - } } } } } + } } } } }, + { "VK_EXT_zero_initialize_device_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } }; auto depIt = dependencies.find( extension ); return ( depIt != dependencies.end() ) ? depIt->second : noDependencies; @@ -2721,6 +2735,7 @@ namespace VULKAN_HPP_NAMESPACE { "VK_EXT_shader_demote_to_helper_invocation", "VK_VERSION_1_3" }, { "VK_KHR_shader_integer_dot_product", "VK_VERSION_1_3" }, { "VK_EXT_texel_buffer_alignment", "VK_VERSION_1_3" }, + { "VK_EXT_robustness2", "VK_KHR_robustness2" }, { "VK_KHR_shader_non_semantic_info", "VK_VERSION_1_3" }, { "VK_EXT_private_data", "VK_VERSION_1_3" }, { "VK_EXT_pipeline_creation_cache_control", "VK_VERSION_1_3" }, @@ -3148,6 +3163,10 @@ namespace VULKAN_HPP_NAMESPACE { return "VK_VERSION_1_3"; } + if ( extension == "VK_EXT_robustness2" ) + { + return "VK_KHR_robustness2"; + } if ( extension == "VK_KHR_shader_non_semantic_info" ) { return "VK_VERSION_1_3"; @@ -3491,11 +3510,11 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_USE_PLATFORM_METAL_EXT ) || ( extension == "VK_EXT_external_memory_metal" ) #endif /*VK_USE_PLATFORM_METAL_EXT*/ - || ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" ) + || ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" ) || ( extension == "VK_KHR_robustness2" ) #if defined( VK_ENABLE_BETA_EXTENSIONS ) || ( extension == "VK_NV_present_metering" ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || ( extension == "VK_EXT_fragment_density_map_offset" ); + || ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ); } VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ) @@ -3597,7 +3616,7 @@ namespace VULKAN_HPP_NAMESPACE ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_host_image_copy" ) || ( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || - ( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) || + ( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_EXT_robustness2" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || diff --git a/third_party/vulkan/vulkan_format_traits.hpp b/third_party/vulkan/vulkan_format_traits.hpp index d5802f5..968f60e 100644 --- a/third_party/vulkan/vulkan_format_traits.hpp +++ b/third_party/vulkan/vulkan_format_traits.hpp @@ -12,11 +12,81 @@ namespace VULKAN_HPP_NAMESPACE { - //===================== //=== Format Traits === //===================== + //=== Function Declarations === + + // The three-dimensional extent of a texel block. + VULKAN_HPP_CONSTEXPR_14 std::array blockExtent( VULKAN_HPP_NAMESPACE::Format format ); + + // The texel block size in bytes. + VULKAN_HPP_CONSTEXPR_14 uint8_t blockSize( VULKAN_HPP_NAMESPACE::Format format ); + + // The class of the format (can't be just named "class"!) + VULKAN_HPP_CONSTEXPR_14 char const * compatibilityClass( VULKAN_HPP_NAMESPACE::Format format ); + + // The number of bits in this component, if not compressed, otherwise 0. + VULKAN_HPP_CONSTEXPR_14 uint8_t componentBits( VULKAN_HPP_NAMESPACE::Format format, uint8_t component ); + + // The number of components of this format. + VULKAN_HPP_CONSTEXPR_14 uint8_t componentCount( VULKAN_HPP_NAMESPACE::Format format ); + + // The name of the component + VULKAN_HPP_CONSTEXPR_14 char const * componentName( VULKAN_HPP_NAMESPACE::Format format, uint8_t component ); + + // The numeric format of the component + VULKAN_HPP_CONSTEXPR_14 char const * componentNumericFormat( VULKAN_HPP_NAMESPACE::Format format, uint8_t component ); + + // The plane this component lies in. + VULKAN_HPP_CONSTEXPR_14 uint8_t componentPlaneIndex( VULKAN_HPP_NAMESPACE::Format format, uint8_t component ); + + // True, if the components of this format are compressed, otherwise false. + VULKAN_HPP_CONSTEXPR_14 bool componentsAreCompressed( VULKAN_HPP_NAMESPACE::Format format ); + + // A textual description of the compression scheme, or an empty string if it is not compressed + VULKAN_HPP_CONSTEXPR_14 char const * compressionScheme( VULKAN_HPP_NAMESPACE::Format format ); + + // Get all formats with a depth component + std::vector const & getDepthFormats(); + + // Get all formats with a depth and a stencil component + std::vector const & getDepthStencilFormats(); + + // Get all formats with a stencil component + std::vector const & getStencilFormats(); + + // True, if this format has a depth component + VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( VULKAN_HPP_NAMESPACE::Format format ); + + // True, if this format has a stencil component + VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( VULKAN_HPP_NAMESPACE::Format format ); + + // True, if this format is a compressed one. + VULKAN_HPP_CONSTEXPR_14 bool isCompressed( VULKAN_HPP_NAMESPACE::Format format ); + + // The number of bits into which the format is packed. A single image element in this format can be stored in the same space as a scalar type of this bit + // width. + VULKAN_HPP_CONSTEXPR_14 uint8_t packed( VULKAN_HPP_NAMESPACE::Format format ); + + // The single-plane format that this plane is compatible with. + VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_NAMESPACE::Format planeCompatibleFormat( VULKAN_HPP_NAMESPACE::Format format, uint8_t plane ); + + // The number of image planes of this format. + VULKAN_HPP_CONSTEXPR_14 uint8_t planeCount( VULKAN_HPP_NAMESPACE::Format format ); + + // The relative height of this plane. A value of k means that this plane is 1/k the height of the overall format. + VULKAN_HPP_CONSTEXPR_14 uint8_t planeHeightDivisor( VULKAN_HPP_NAMESPACE::Format format, uint8_t plane ); + + // The relative width of this plane. A value of k means that this plane is 1/k the width of the overall format. + VULKAN_HPP_CONSTEXPR_14 uint8_t planeWidthDivisor( VULKAN_HPP_NAMESPACE::Format format, uint8_t plane ); + + // The number of texels in a texel block. + VULKAN_HPP_CONSTEXPR_14 uint8_t texelsPerBlock( VULKAN_HPP_NAMESPACE::Format format ); + + //=== Function Definitions === + // The three-dimensional extent of a texel block. VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 std::array blockExtent( VULKAN_HPP_NAMESPACE::Format format ) { @@ -6730,6 +6800,63 @@ namespace VULKAN_HPP_NAMESPACE } } + // Get all formats with a depth component + VULKAN_HPP_INLINE std::vector const & getDepthFormats() + { + static std::vector depthFormats = { + VULKAN_HPP_NAMESPACE::Format::eD16Unorm, VULKAN_HPP_NAMESPACE::Format::eX8D24UnormPack32, VULKAN_HPP_NAMESPACE::Format::eD32Sfloat, + VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint, VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint, VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint + }; + return depthFormats; + } + + // Get all formats with a depth and a stencil component + VULKAN_HPP_INLINE std::vector const & getDepthStencilFormats() + { + static std::vector depthStencilFormats = { VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint, + VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint, + VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint }; + return depthStencilFormats; + } + + // Get all formats with a stencil component + VULKAN_HPP_INLINE std::vector const & getStencilFormats() + { + static std::vector stencilFormats = { VULKAN_HPP_NAMESPACE::Format::eS8Uint, + VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint, + VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint, + VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint }; + return stencilFormats; + } + + // True, if this format has a depth component + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( VULKAN_HPP_NAMESPACE::Format format ) + { + switch ( format ) + { + case VULKAN_HPP_NAMESPACE::Format::eD16Unorm: + case VULKAN_HPP_NAMESPACE::Format::eX8D24UnormPack32: + case VULKAN_HPP_NAMESPACE::Format::eD32Sfloat: + case VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint: + case VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint: + case VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint: return true; + default: return false; + } + } + + // True, if this format has a stencil component + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( VULKAN_HPP_NAMESPACE::Format format ) + { + switch ( format ) + { + case VULKAN_HPP_NAMESPACE::Format::eS8Uint: + case VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint: + case VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint: + case VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint: return true; + default: return false; + } + } + // True, if this format is a compressed one. VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool isCompressed( VULKAN_HPP_NAMESPACE::Format format ) { diff --git a/third_party/vulkan/vulkan_funcs.hpp b/third_party/vulkan/vulkan_funcs.hpp index e033d3b..2353874 100644 --- a/third_party/vulkan/vulkan_funcs.hpp +++ b/third_party/vulkan/vulkan_funcs.hpp @@ -25005,35 +25005,15 @@ namespace VULKAN_HPP_NAMESPACE # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT - Device::exportMetalObjectsEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function requires " ); # endif - VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo; d.vkExportMetalObjectsEXT( m_device, reinterpret_cast( &metalObjectsInfo ) ); - - return metalObjectsInfo; - } - - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain - Device::exportMetalObjectsEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function requires " ); -# endif - - VULKAN_HPP_NAMESPACE::StructureChain structureChain; - VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo = structureChain.template get(); - d.vkExportMetalObjectsEXT( m_device, reinterpret_cast( &metalObjectsInfo ) ); - - return structureChain; } # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_METAL_EXT*/ diff --git a/third_party/vulkan/vulkan_handles.hpp b/third_party/vulkan/vulkan_handles.hpp index a08b8bb..61e800f 100644 --- a/third_party/vulkan/vulkan_handles.hpp +++ b/third_party/vulkan/vulkan_handles.hpp @@ -1303,10 +1303,6 @@ namespace VULKAN_HPP_NAMESPACE struct DeviceDeviceMemoryReportCreateInfoEXT; struct DeviceMemoryReportCallbackDataEXT; - //=== VK_EXT_robustness2 === - struct PhysicalDeviceRobustness2FeaturesEXT; - struct PhysicalDeviceRobustness2PropertiesEXT; - //=== VK_EXT_custom_border_color === struct SamplerCustomBorderColorCreateInfoEXT; struct PhysicalDeviceCustomBorderColorPropertiesEXT; @@ -2059,6 +2055,12 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_vertex_attribute_robustness === struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + //=== VK_KHR_robustness2 === + struct PhysicalDeviceRobustness2FeaturesKHR; + using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR; + struct PhysicalDeviceRobustness2PropertiesKHR; + using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR; + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_present_metering === struct SetPresentConfigNV; @@ -2074,6 +2076,9 @@ namespace VULKAN_HPP_NAMESPACE struct RenderPassFragmentDensityMapOffsetEndInfoEXT; using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT; + //=== VK_EXT_zero_initialize_device_memory === + struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + //=================================== //=== HANDLE forward declarations === //=================================== @@ -16057,12 +16062,8 @@ namespace VULKAN_HPP_NAMESPACE # ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html template - VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT - exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain - exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_USE_PLATFORM_METAL_EXT*/ diff --git a/third_party/vulkan/vulkan_hash.hpp b/third_party/vulkan/vulkan_hash.hpp index ff23902..d9711b8 100644 --- a/third_party/vulkan/vulkan_hash.hpp +++ b/third_party/vulkan/vulkan_hash.hpp @@ -12259,31 +12259,31 @@ namespace std }; template <> - struct hash + struct hash { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const & physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR const & physicalDeviceRobustness2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT { std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustBufferAccess2 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustImageAccess2 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.nullDescriptor ); return seed; } }; template <> - struct hash + struct hash { std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const & physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR const & physicalDeviceRobustness2PropertiesKHR ) const VULKAN_HPP_NOEXCEPT { std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustStorageBufferAccessSizeAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustUniformBufferAccessSizeAlignment ); return seed; } }; @@ -14089,6 +14089,21 @@ namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.zeroInitializeDeviceMemory ); + return seed; + } + }; + template <> struct hash { diff --git a/third_party/vulkan/vulkan_raii.hpp b/third_party/vulkan/vulkan_raii.hpp index 8fdaa85..1bf0173 100644 --- a/third_party/vulkan/vulkan_raii.hpp +++ b/third_party/vulkan/vulkan_raii.hpp @@ -2885,12 +2885,18 @@ namespace VULKAN_HPP_NAMESPACE class CuModuleNVX; class CuFunctionNVX; + //=== VK_KHR_descriptor_update_template === + using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; + //=== VK_EXT_debug_utils === class DebugUtilsMessengerEXT; //=== VK_KHR_acceleration_structure === class AccelerationStructureKHR; + //=== VK_KHR_sampler_ycbcr_conversion === + using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; + //=== VK_EXT_validation_cache === class ValidationCacheEXT; @@ -2906,6 +2912,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_device_generated_commands === class IndirectCommandsLayoutNV; + //=== VK_EXT_private_data === + using PrivateDataSlotEXT = PrivateDataSlot; + # if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_cuda_kernel_launch === class CudaModuleNV; @@ -5199,11 +5208,7 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_metal_objects === // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT; + void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo ) const VULKAN_HPP_NOEXCEPT; # endif /*VK_USE_PLATFORM_METAL_EXT*/ //=== VK_EXT_descriptor_buffer === @@ -24503,27 +24508,11 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_metal_objects === // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT + VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function requires " ); - VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo; getDispatcher()->vkExportMetalObjectsEXT( static_cast( m_device ), reinterpret_cast( &metalObjectsInfo ) ); - - return metalObjectsInfo; - } - - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::StructureChain structureChain; - VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo = structureChain.template get(); - getDispatcher()->vkExportMetalObjectsEXT( static_cast( m_device ), reinterpret_cast( &metalObjectsInfo ) ); - - return structureChain; } # endif /*VK_USE_PLATFORM_METAL_EXT*/ diff --git a/third_party/vulkan/vulkan_static_assertions.hpp b/third_party/vulkan/vulkan_static_assertions.hpp index ebfc9bf..005911c 100644 --- a/third_party/vulkan/vulkan_static_assertions.hpp +++ b/third_party/vulkan/vulkan_static_assertions.hpp @@ -5183,22 +5183,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "DeviceMemoryReportCallbackDataEXT is not nothrow_move_constructible!" ); -//=== VK_EXT_robustness2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT ) == sizeof( VkPhysicalDeviceRobustness2FeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRobustness2FeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT ) == sizeof( VkPhysicalDeviceRobustness2PropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRobustness2PropertiesEXT is not nothrow_move_constructible!" ); - //=== VK_EXT_custom_border_color === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT ) == sizeof( VkSamplerCustomBorderColorCreateInfoEXT ), @@ -8623,6 +8607,22 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT is not nothrow_move_constructible!" ); +//=== VK_KHR_robustness2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR ) == sizeof( VkPhysicalDeviceRobustness2FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRobustness2FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR ) == sizeof( VkPhysicalDeviceRobustness2PropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRobustness2PropertiesKHR is not nothrow_move_constructible!" ); + #if defined( VK_ENABLE_BETA_EXTENSIONS ) //=== VK_NV_present_metering === @@ -8670,4 +8670,14 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "RenderPassFragmentDensityMapOffsetEndInfoEXT is not nothrow_move_constructible!" ); +//=== VK_EXT_zero_initialize_device_memory === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ) == + sizeof( VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT is not nothrow_move_constructible!" ); + #endif diff --git a/third_party/vulkan/vulkan_structs.hpp b/third_party/vulkan/vulkan_structs.hpp index 6181aad..38847ff 100644 --- a/third_party/vulkan/vulkan_structs.hpp +++ b/third_party/vulkan/vulkan_structs.hpp @@ -100076,17 +100076,17 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; }; - // wrapper struct for struct VkPhysicalDeviceRobustness2FeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html - struct PhysicalDeviceRobustness2FeaturesEXT + // wrapper struct for struct VkPhysicalDeviceRobustness2FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2FeaturesKHR.html + struct PhysicalDeviceRobustness2FeaturesKHR { - using NativeType = VkPhysicalDeviceRobustness2FeaturesEXT; + using NativeType = VkPhysicalDeviceRobustness2FeaturesKHR; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2FeaturesEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2FeaturesKHR; #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ = {}, + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ = {}, VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ = {}, VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT @@ -100097,67 +100097,67 @@ namespace VULKAN_HPP_NAMESPACE { } - VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesEXT( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesKHR( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - PhysicalDeviceRobustness2FeaturesEXT( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRobustness2FeaturesEXT( *reinterpret_cast( &rhs ) ) + PhysicalDeviceRobustness2FeaturesKHR( VkPhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRobustness2FeaturesKHR( *reinterpret_cast( &rhs ) ) { } - PhysicalDeviceRobustness2FeaturesEXT & operator=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + PhysicalDeviceRobustness2FeaturesKHR & operator=( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - PhysicalDeviceRobustness2FeaturesEXT & operator=( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + PhysicalDeviceRobustness2FeaturesKHR & operator=( VkPhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } #if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesEXT & + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setRobustBufferAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ ) VULKAN_HPP_NOEXCEPT { robustBufferAccess2 = robustBufferAccess2_; return *this; } - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesEXT & setRobustImageAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setRobustImageAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ ) VULKAN_HPP_NOEXCEPT { robustImageAccess2 = robustImageAccess2_; return *this; } - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesEXT & setNullDescriptor( VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setNullDescriptor( VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ ) VULKAN_HPP_NOEXCEPT { nullDescriptor = nullDescriptor_; return *this; } #endif /*VULKAN_HPP_NO_SETTERS*/ - operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceRobustness2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceRobustness2FeaturesKHR &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRobustness2FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceRobustness2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } - operator VkPhysicalDeviceRobustness2FeaturesEXT *() VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceRobustness2FeaturesKHR *() VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } #if defined( VULKAN_HPP_USE_REFLECT ) @@ -100177,9 +100177,9 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const & ) const = default; + auto operator<=>( PhysicalDeviceRobustness2FeaturesKHR const & ) const = default; #else - bool operator==( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); @@ -100189,14 +100189,14 @@ namespace VULKAN_HPP_NAMESPACE # endif } - bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } #endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2FeaturesEXT; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2FeaturesKHR; void * pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2 = {}; VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2 = {}; @@ -100204,22 +100204,24 @@ namespace VULKAN_HPP_NAMESPACE }; template <> - struct CppType + struct CppType { - using Type = PhysicalDeviceRobustness2FeaturesEXT; + using Type = PhysicalDeviceRobustness2FeaturesKHR; }; - // wrapper struct for struct VkPhysicalDeviceRobustness2PropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html - struct PhysicalDeviceRobustness2PropertiesEXT + using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR; + + // wrapper struct for struct VkPhysicalDeviceRobustness2PropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2PropertiesKHR.html + struct PhysicalDeviceRobustness2PropertiesKHR { - using NativeType = VkPhysicalDeviceRobustness2PropertiesEXT; + using NativeType = VkPhysicalDeviceRobustness2PropertiesKHR; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2PropertiesEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2PropertiesKHR; #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment_ = {}, + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesKHR( VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize robustUniformBufferAccessSizeAlignment_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } @@ -100228,40 +100230,40 @@ namespace VULKAN_HPP_NAMESPACE { } - VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesEXT( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesKHR( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - PhysicalDeviceRobustness2PropertiesEXT( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRobustness2PropertiesEXT( *reinterpret_cast( &rhs ) ) + PhysicalDeviceRobustness2PropertiesKHR( VkPhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRobustness2PropertiesKHR( *reinterpret_cast( &rhs ) ) { } - PhysicalDeviceRobustness2PropertiesEXT & operator=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + PhysicalDeviceRobustness2PropertiesKHR & operator=( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - PhysicalDeviceRobustness2PropertiesEXT & operator=( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + PhysicalDeviceRobustness2PropertiesKHR & operator=( VkPhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + *this = *reinterpret_cast( &rhs ); return *this; } - operator VkPhysicalDeviceRobustness2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceRobustness2PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceRobustness2PropertiesKHR &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkPhysicalDeviceRobustness2PropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceRobustness2PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } - operator VkPhysicalDeviceRobustness2PropertiesEXT *() VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceRobustness2PropertiesKHR *() VULKAN_HPP_NOEXCEPT { - return reinterpret_cast( this ); + return reinterpret_cast( this ); } #if defined( VULKAN_HPP_USE_REFLECT ) @@ -100277,9 +100279,9 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const & ) const = default; + auto operator<=>( PhysicalDeviceRobustness2PropertiesKHR const & ) const = default; #else - bool operator==( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); @@ -100289,25 +100291,27 @@ namespace VULKAN_HPP_NAMESPACE # endif } - bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } #endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2PropertiesEXT; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2PropertiesKHR; void * pNext = {}; VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment = {}; VULKAN_HPP_NAMESPACE::DeviceSize robustUniformBufferAccessSizeAlignment = {}; }; template <> - struct CppType + struct CppType { - using Type = PhysicalDeviceRobustness2PropertiesEXT; + using Type = PhysicalDeviceRobustness2PropertiesKHR; }; + using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR; + // wrapper struct for struct VkPhysicalDeviceSampleLocationsPropertiesEXT, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html struct PhysicalDeviceSampleLocationsPropertiesEXT @@ -114234,6 +114238,118 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT; }; + // wrapper struct for struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.html + struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT + { + using NativeType = VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 zeroInitializeDeviceMemory_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , zeroInitializeDeviceMemory{ zeroInitializeDeviceMemory_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & + operator=( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & operator=( VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & + setZeroInitializeDeviceMemory( VULKAN_HPP_NAMESPACE::Bool32 zeroInitializeDeviceMemory_ ) VULKAN_HPP_NOEXCEPT + { + zeroInitializeDeviceMemory = zeroInitializeDeviceMemory_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, zeroInitializeDeviceMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT 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 ) && ( zeroInitializeDeviceMemory == rhs.zeroInitializeDeviceMemory ); +# endif + } + + bool operator!=( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 zeroInitializeDeviceMemory = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + }; + // wrapper struct for struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.html struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures diff --git a/third_party/vulkan/vulkan_to_string.hpp b/third_party/vulkan/vulkan_to_string.hpp index 8042739..ecc7045 100644 --- a/third_party/vulkan/vulkan_to_string.hpp +++ b/third_party/vulkan/vulkan_to_string.hpp @@ -1341,6 +1341,8 @@ namespace VULKAN_HPP_NAMESPACE result += " DeviceAddress |"; if ( value & MemoryAllocateFlagBits::eDeviceAddressCaptureReplay ) result += " DeviceAddressCaptureReplay |"; + if ( value & MemoryAllocateFlagBits::eZeroInitializeEXT ) + result += " ZeroInitializeEXT |"; if ( result.size() > 1 ) result.back() = '}'; @@ -4717,8 +4719,6 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT: return "PhysicalDeviceDeviceMemoryReportFeaturesEXT"; case StructureType::eDeviceDeviceMemoryReportCreateInfoEXT: return "DeviceDeviceMemoryReportCreateInfoEXT"; case StructureType::eDeviceMemoryReportCallbackDataEXT: return "DeviceMemoryReportCallbackDataEXT"; - case StructureType::ePhysicalDeviceRobustness2FeaturesEXT: return "PhysicalDeviceRobustness2FeaturesEXT"; - case StructureType::ePhysicalDeviceRobustness2PropertiesEXT: return "PhysicalDeviceRobustness2PropertiesEXT"; case StructureType::eSamplerCustomBorderColorCreateInfoEXT: return "SamplerCustomBorderColorCreateInfoEXT"; case StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT: return "PhysicalDeviceCustomBorderColorPropertiesEXT"; case StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT: return "PhysicalDeviceCustomBorderColorFeaturesEXT"; @@ -5130,6 +5130,8 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_METAL_EXT*/ case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR: return "PhysicalDeviceDepthClampZeroOneFeaturesKHR"; case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT: return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT"; + case StructureType::ePhysicalDeviceRobustness2FeaturesKHR: return "PhysicalDeviceRobustness2FeaturesKHR"; + case StructureType::ePhysicalDeviceRobustness2PropertiesKHR: return "PhysicalDeviceRobustness2PropertiesKHR"; #if defined( VK_ENABLE_BETA_EXTENSIONS ) case StructureType::eSetPresentConfigNV: return "SetPresentConfigNV"; case StructureType::ePhysicalDevicePresentMeteringFeaturesNV: return "PhysicalDevicePresentMeteringFeaturesNV"; @@ -5138,6 +5140,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT: return "PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"; case StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT: return "RenderPassFragmentDensityMapOffsetEndInfoEXT"; case StructureType::eRenderingEndInfoEXT: return "RenderingEndInfoEXT"; + case StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT: return "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6004,6 +6007,7 @@ namespace VULKAN_HPP_NAMESPACE case ImageLayout::eVideoEncodeDpbKHR: return "VideoEncodeDpbKHR"; case ImageLayout::eAttachmentFeedbackLoopOptimalEXT: return "AttachmentFeedbackLoopOptimalEXT"; case ImageLayout::eVideoEncodeQuantizationMapKHR: return "VideoEncodeQuantizationMapKHR"; + case ImageLayout::eZeroInitializedEXT: return "ZeroInitializedEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6889,6 +6893,7 @@ namespace VULKAN_HPP_NAMESPACE case MemoryAllocateFlagBits::eDeviceMask: return "DeviceMask"; case MemoryAllocateFlagBits::eDeviceAddress: return "DeviceAddress"; case MemoryAllocateFlagBits::eDeviceAddressCaptureReplay: return "DeviceAddressCaptureReplay"; + case MemoryAllocateFlagBits::eZeroInitializeEXT: return "ZeroInitializeEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } }