From 46dc0f6e514f5730784bb2cac2a7c731636839e8 Mon Sep 17 00:00:00 2001 From: Jon Leech Date: Fri, 1 Mar 2024 06:25:39 -0800 Subject: Update for Vulkan-Docs 1.3.279 --- include/vulkan/vulkan.cppm | 7 + include/vulkan/vulkan.hpp | 34 +++- include/vulkan/vulkan_core.h | 19 +- include/vulkan/vulkan_enums.hpp | 35 ++-- include/vulkan/vulkan_extension_inspection.hpp | 4 +- include/vulkan/vulkan_handles.hpp | 3 + include/vulkan/vulkan_hash.hpp | 14 ++ include/vulkan/vulkan_static_assertions.hpp | 9 + include/vulkan/vulkan_structs.hpp | 259 ++++++++++++++++++++++--- include/vulkan/vulkan_to_string.hpp | 5 +- 10 files changed, 332 insertions(+), 57 deletions(-) (limited to 'include') diff --git a/include/vulkan/vulkan.cppm b/include/vulkan/vulkan.cppm index a408a68..309b807 100644 --- a/include/vulkan/vulkan.cppm +++ b/include/vulkan/vulkan.cppm @@ -2494,6 +2494,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName; using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion; + //=== VK_NV_raw_access_chains === + using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName; + using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion; + //=== VK_NV_shader_atomic_float16_vector === using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName; using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion; @@ -4335,6 +4339,9 @@ export namespace VULKAN_HPP_NAMESPACE //=== VK_NV_descriptor_pool_overallocation === using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + //=== VK_NV_raw_access_chains === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV; + //=== VK_NV_shader_atomic_float16_vector === using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index e9babb5..4494d56 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 278, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 279, "Wrong VK_HEADER_VERSION!" ); // includes through some other header // this results in major(x) being resolved to gnu_dev_major(x) @@ -8662,6 +8662,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationExtensionName = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationSpecVersion = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION; + //=== VK_NV_raw_access_chains === + VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsExtensionName = VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsSpecVersion = VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION; + //=== 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 NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION; @@ -15150,6 +15154,15 @@ namespace VULKAN_HPP_NAMESPACE }; }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_NV_linear_color_attachment === template <> struct StructExtends @@ -16588,6 +16601,25 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_NV_raw_access_chains === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_NV_shader_atomic_float16_vector === template <> struct StructExtends diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index 7e6b040..e2656ee 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/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 278 +#define VK_HEADER_VERSION 279 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) @@ -1109,6 +1109,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007, VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, 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_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, 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, @@ -11157,12 +11158,8 @@ static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFF static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000ULL; static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000ULL; static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00004000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000ULL; -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000ULL; -#endif static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000ULL; static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000ULL; static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000ULL; @@ -19113,6 +19110,18 @@ typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { +// VK_NV_raw_access_chains is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_raw_access_chains 1 +#define VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION 1 +#define VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME "VK_NV_raw_access_chains" +typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shaderRawAccessChains; +} VkPhysicalDeviceRawAccessChainsFeaturesNV; + + + // VK_NV_shader_atomic_float16_vector is a preprocessor guard. Do not pass it to API calls. #define VK_NV_shader_atomic_float16_vector 1 #define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION 1 diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp index 2ddc619..4306fec 100644 --- a/include/vulkan/vulkan_enums.hpp +++ b/include/vulkan/vulkan_enums.hpp @@ -1422,6 +1422,7 @@ namespace VULKAN_HPP_NAMESPACE eSetDescriptorBufferOffsetsInfoEXT = VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT, eBindDescriptorBufferEmbeddedSamplersInfoEXT = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT, ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, + ePhysicalDeviceRawAccessChainsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV }; @@ -6990,17 +6991,15 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) eExecutionGraphScratchAMDX = VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eConditionalRenderingEXT = VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT, - eShaderBindingTable = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR, - eRayTracingNV = VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV, - eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, - eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, - eVideoDecodeSrc = VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR, - eVideoDecodeDst = VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eVideoEncodeDst = VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR, - eVideoEncodeSrc = VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eConditionalRenderingEXT = VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT, + eShaderBindingTable = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR, + eRayTracingNV = VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV, + eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, + eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, + eVideoDecodeSrc = VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR, + eVideoDecodeDst = VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR, + eVideoEncodeDst = VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR, + eVideoEncodeSrc = VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR, eShaderDeviceAddress = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR, eAccelerationStructureBuildInputReadOnly = VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, eAccelerationStructureStorage = VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR, @@ -7026,14 +7025,12 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_ENABLE_BETA_EXTENSIONS*/ | BufferUsageFlagBits2KHR::eConditionalRenderingEXT | BufferUsageFlagBits2KHR::eShaderBindingTable | BufferUsageFlagBits2KHR::eTransformFeedbackBufferEXT | BufferUsageFlagBits2KHR::eTransformFeedbackCounterBufferEXT | - BufferUsageFlagBits2KHR::eVideoDecodeSrc | BufferUsageFlagBits2KHR::eVideoDecodeDst -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | BufferUsageFlagBits2KHR::eVideoEncodeDst | BufferUsageFlagBits2KHR::eVideoEncodeSrc -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | BufferUsageFlagBits2KHR::eShaderDeviceAddress | BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly | - BufferUsageFlagBits2KHR::eAccelerationStructureStorage | BufferUsageFlagBits2KHR::eSamplerDescriptorBufferEXT | - BufferUsageFlagBits2KHR::eResourceDescriptorBufferEXT | BufferUsageFlagBits2KHR::ePushDescriptorsDescriptorBufferEXT | - BufferUsageFlagBits2KHR::eMicromapBuildInputReadOnlyEXT | BufferUsageFlagBits2KHR::eMicromapStorageEXT; + BufferUsageFlagBits2KHR::eVideoDecodeSrc | BufferUsageFlagBits2KHR::eVideoDecodeDst | BufferUsageFlagBits2KHR::eVideoEncodeDst | + BufferUsageFlagBits2KHR::eVideoEncodeSrc | BufferUsageFlagBits2KHR::eShaderDeviceAddress | + BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly | BufferUsageFlagBits2KHR::eAccelerationStructureStorage | + BufferUsageFlagBits2KHR::eSamplerDescriptorBufferEXT | BufferUsageFlagBits2KHR::eResourceDescriptorBufferEXT | + BufferUsageFlagBits2KHR::ePushDescriptorsDescriptorBufferEXT | BufferUsageFlagBits2KHR::eMicromapBuildInputReadOnlyEXT | + BufferUsageFlagBits2KHR::eMicromapStorageEXT; }; //=== VK_EXT_shader_object === diff --git a/include/vulkan/vulkan_extension_inspection.hpp b/include/vulkan/vulkan_extension_inspection.hpp index 6c5c6ea..41e0228 100644 --- a/include/vulkan/vulkan_extension_inspection.hpp +++ b/include/vulkan/vulkan_extension_inspection.hpp @@ -434,6 +434,7 @@ namespace VULKAN_HPP_NAMESPACE "VK_KHR_shader_expect_assume", "VK_KHR_maintenance6", "VK_NV_descriptor_pool_overallocation", + "VK_NV_raw_access_chains", "VK_NV_shader_atomic_float16_vector" }; return deviceExtensions; @@ -2874,7 +2875,8 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ || ( 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_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ); + ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_raw_access_chains" ) || + ( extension == "VK_NV_shader_atomic_float16_vector" ); } VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ) diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp index 945bd34..289ff80 100644 --- a/include/vulkan/vulkan_handles.hpp +++ b/include/vulkan/vulkan_handles.hpp @@ -1820,6 +1820,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_descriptor_pool_overallocation === struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + //=== VK_NV_raw_access_chains === + struct PhysicalDeviceRawAccessChainsFeaturesNV; + //=== VK_NV_shader_atomic_float16_vector === struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp index 7bb3216..a023933 100644 --- a/include/vulkan/vulkan_hash.hpp +++ b/include/vulkan/vulkan_hash.hpp @@ -10653,6 +10653,20 @@ namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV const & physicalDeviceRawAccessChainsFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.shaderRawAccessChains ); + return seed; + } + }; + template <> struct hash { diff --git a/include/vulkan/vulkan_static_assertions.hpp b/include/vulkan/vulkan_static_assertions.hpp index 07c3078..6c98ba3 100644 --- a/include/vulkan/vulkan_static_assertions.hpp +++ b/include/vulkan/vulkan_static_assertions.hpp @@ -7474,6 +7474,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" ); +//=== VK_NV_raw_access_chains === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV ) == sizeof( VkPhysicalDeviceRawAccessChainsFeaturesNV ), + "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, + "PhysicalDeviceRawAccessChainsFeaturesNV is not nothrow_move_constructible!" ); + //=== VK_NV_shader_atomic_float16_vector === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ) == diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp index 93e911a..4289d28 100644 --- a/include/vulkan/vulkan_structs.hpp +++ b/include/vulkan/vulkan_structs.hpp @@ -27655,7 +27655,11 @@ namespace VULKAN_HPP_NAMESPACE : vendorFaultCode( vendorFaultCode_ ), vendorFaultData( vendorFaultData_ ) { VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -27679,7 +27683,11 @@ namespace VULKAN_HPP_NAMESPACE DeviceFaultVendorInfoEXT & setDescription( std::string const & description_ ) VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif return *this; } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -35660,7 +35668,11 @@ namespace VULKAN_HPP_NAMESPACE ExtensionProperties( std::string const & extensionName_, uint32_t specVersion_ = {} ) : specVersion( specVersion_ ) { VULKAN_HPP_ASSERT( extensionName_.size() < VK_MAX_EXTENSION_NAME_SIZE ); - strncpy( extensionName, extensionName_.data(), std::min( extensionName_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( extensionName, VK_MAX_EXTENSION_NAME_SIZE, extensionName_.data(), extensionName_.size() ); +# else + strncpy( extensionName, extensionName_.data(), std::min( VK_MAX_EXTENSION_NAME_SIZE, extensionName_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -49675,9 +49687,18 @@ namespace VULKAN_HPP_NAMESPACE : specVersion( specVersion_ ), implementationVersion( implementationVersion_ ) { VULKAN_HPP_ASSERT( layerName_.size() < VK_MAX_EXTENSION_NAME_SIZE ); - strncpy( layerName, layerName_.data(), std::min( layerName_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( layerName, VK_MAX_EXTENSION_NAME_SIZE, layerName_.data(), layerName_.size() ); +# else + strncpy( layerName, layerName_.data(), std::min( VK_MAX_EXTENSION_NAME_SIZE, layerName_.size() ) ); +# endif + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -55149,11 +55170,25 @@ namespace VULKAN_HPP_NAMESPACE : pNext( pNext_ ), flags( flags_ ) { VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( name, VK_MAX_DESCRIPTION_SIZE, name_.data(), name_.size() ); +# else + strncpy( name, name_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, name_.size() ) ); +# endif + VULKAN_HPP_ASSERT( category_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( category, category_.data(), std::min( category_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( category, VK_MAX_DESCRIPTION_SIZE, category_.data(), category_.size() ); +# else + strncpy( category, category_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, category_.size() ) ); +# endif + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -62636,9 +62671,18 @@ namespace VULKAN_HPP_NAMESPACE : pNext( pNext_ ), driverID( driverID_ ), conformanceVersion( conformanceVersion_ ) { VULKAN_HPP_ASSERT( driverName_.size() < VK_MAX_DRIVER_NAME_SIZE ); - strncpy( driverName, driverName_.data(), std::min( driverName_.size(), VK_MAX_DRIVER_NAME_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( driverName, VK_MAX_DRIVER_NAME_SIZE, driverName_.data(), driverName_.size() ); +# else + strncpy( driverName, driverName_.data(), std::min( VK_MAX_DRIVER_NAME_SIZE, driverName_.size() ) ); +# endif + VULKAN_HPP_ASSERT( driverInfo_.size() < VK_MAX_DRIVER_INFO_SIZE ); - strncpy( driverInfo, driverInfo_.data(), std::min( driverInfo_.size(), VK_MAX_DRIVER_INFO_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( driverInfo, VK_MAX_DRIVER_INFO_SIZE, driverInfo_.data(), driverInfo_.size() ); +# else + strncpy( driverInfo, driverInfo_.data(), std::min( VK_MAX_DRIVER_INFO_SIZE, driverInfo_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -77468,7 +77512,11 @@ namespace VULKAN_HPP_NAMESPACE , sparseProperties( sparseProperties_ ) { VULKAN_HPP_ASSERT( deviceName_.size() < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ); - strncpy( deviceName, deviceName_.data(), std::min( deviceName_.size(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, deviceName_.data(), deviceName_.size() ); +# else + strncpy( deviceName, deviceName_.data(), std::min( VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, deviceName_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -77512,7 +77560,7 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + std::partial_ordering operator<=>( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { if ( auto cmp = apiVersion <=> rhs.apiVersion; cmp != 0 ) return cmp; @@ -77525,7 +77573,7 @@ namespace VULKAN_HPP_NAMESPACE if ( auto cmp = deviceType <=> rhs.deviceType; cmp != 0 ) return cmp; if ( auto cmp = strcmp( deviceName, rhs.deviceName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater; if ( auto cmp = pipelineCacheUUID <=> rhs.pipelineCacheUUID; cmp != 0 ) return cmp; if ( auto cmp = limits <=> rhs.limits; cmp != 0 ) @@ -77533,7 +77581,7 @@ namespace VULKAN_HPP_NAMESPACE if ( auto cmp = sparseProperties <=> rhs.sparseProperties; cmp != 0 ) return cmp; - return std::strong_ordering::equivalent; + return std::partial_ordering::equivalent; } #endif @@ -78334,6 +78382,104 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + struct PhysicalDeviceRawAccessChainsFeaturesNV + { + using NativeType = VkPhysicalDeviceRawAccessChainsFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRawAccessChainsFeaturesNV( VULKAN_HPP_NAMESPACE::Bool32 shaderRawAccessChains_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , shaderRawAccessChains( shaderRawAccessChains_ ) + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRawAccessChainsFeaturesNV( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRawAccessChainsFeaturesNV( VkPhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRawAccessChainsFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRawAccessChainsFeaturesNV & operator=( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceRawAccessChainsFeaturesNV & operator=( VkPhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV & + setShaderRawAccessChains( VULKAN_HPP_NAMESPACE::Bool32 shaderRawAccessChains_ ) VULKAN_HPP_NOEXCEPT + { + shaderRawAccessChains = shaderRawAccessChains_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkPhysicalDeviceRawAccessChainsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRawAccessChainsFeaturesNV &() 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, shaderRawAccessChains ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRawAccessChainsFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceRawAccessChainsFeaturesNV 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 ) && ( shaderRawAccessChains == rhs.shaderRawAccessChains ); +# endif + } + + bool operator!=( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 shaderRawAccessChains = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceRawAccessChainsFeaturesNV; + }; + struct PhysicalDeviceRayQueryFeaturesKHR { using NativeType = VkPhysicalDeviceRayQueryFeaturesKHR; @@ -86740,13 +86886,32 @@ namespace VULKAN_HPP_NAMESPACE : pNext( pNext_ ), purposes( purposes_ ) { VULKAN_HPP_ASSERT( name_.size() < VK_MAX_EXTENSION_NAME_SIZE ); - strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( name, VK_MAX_EXTENSION_NAME_SIZE, name_.data(), name_.size() ); +# else + strncpy( name, name_.data(), std::min( VK_MAX_EXTENSION_NAME_SIZE, name_.size() ) ); +# endif + VULKAN_HPP_ASSERT( version_.size() < VK_MAX_EXTENSION_NAME_SIZE ); - strncpy( version, version_.data(), std::min( version_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( version, VK_MAX_EXTENSION_NAME_SIZE, version_.data(), version_.size() ); +# else + strncpy( version, version_.data(), std::min( VK_MAX_EXTENSION_NAME_SIZE, version_.size() ) ); +# endif + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif + VULKAN_HPP_ASSERT( layer_.size() < VK_MAX_EXTENSION_NAME_SIZE ); - strncpy( layer, layer_.data(), std::min( layer_.size(), VK_MAX_EXTENSION_NAME_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( layer, VK_MAX_EXTENSION_NAME_SIZE, layer_.data(), layer_.size() ); +# else + strncpy( layer, layer_.data(), std::min( VK_MAX_EXTENSION_NAME_SIZE, layer_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -89424,9 +89589,18 @@ namespace VULKAN_HPP_NAMESPACE , framebufferIntegerColorSampleCounts( framebufferIntegerColorSampleCounts_ ) { VULKAN_HPP_ASSERT( driverName_.size() < VK_MAX_DRIVER_NAME_SIZE ); - strncpy( driverName, driverName_.data(), std::min( driverName_.size(), VK_MAX_DRIVER_NAME_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( driverName, VK_MAX_DRIVER_NAME_SIZE, driverName_.data(), driverName_.size() ); +# else + strncpy( driverName, driverName_.data(), std::min( VK_MAX_DRIVER_NAME_SIZE, driverName_.size() ) ); +# endif + VULKAN_HPP_ASSERT( driverInfo_.size() < VK_MAX_DRIVER_INFO_SIZE ); - strncpy( driverInfo, driverInfo_.data(), std::min( driverInfo_.size(), VK_MAX_DRIVER_INFO_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( driverInfo, VK_MAX_DRIVER_INFO_SIZE, driverInfo_.data(), driverInfo_.size() ); +# else + strncpy( driverInfo, driverInfo_.data(), std::min( VK_MAX_DRIVER_INFO_SIZE, driverInfo_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -92731,9 +92905,18 @@ namespace VULKAN_HPP_NAMESPACE : pNext( pNext_ ), isText( isText_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) { VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( name, VK_MAX_DESCRIPTION_SIZE, name_.data(), name_.size() ); +# else + strncpy( name, name_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, name_.size() ) ); +# endif + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -92860,9 +93043,18 @@ namespace VULKAN_HPP_NAMESPACE : pNext( pNext_ ), stages( stages_ ), subgroupSize( subgroupSize_ ) { VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( name, VK_MAX_DESCRIPTION_SIZE, name_.data(), name_.size() ); +# else + strncpy( name, name_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, name_.size() ) ); +# endif + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -93050,9 +93242,18 @@ namespace VULKAN_HPP_NAMESPACE : pNext( pNext_ ), format( format_ ), value( value_ ) { VULKAN_HPP_ASSERT( name_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( name, name_.data(), std::min( name_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( name, VK_MAX_DESCRIPTION_SIZE, name_.data(), name_.size() ); +# else + strncpy( name, name_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, name_.size() ) ); +# endif + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -104104,7 +104305,11 @@ namespace VULKAN_HPP_NAMESPACE : subpassMergeStatus( subpassMergeStatus_ ), postMergeIndex( postMergeIndex_ ) { VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); - strncpy( description, description_.data(), std::min( description_.size(), VK_MAX_DESCRIPTION_SIZE ) ); +# if defined( WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ diff --git a/include/vulkan/vulkan_to_string.hpp b/include/vulkan/vulkan_to_string.hpp index cb3ae0d..ddce545 100644 --- a/include/vulkan/vulkan_to_string.hpp +++ b/include/vulkan/vulkan_to_string.hpp @@ -3472,12 +3472,10 @@ namespace VULKAN_HPP_NAMESPACE result += "VideoDecodeSrc | "; if ( value & BufferUsageFlagBits2KHR::eVideoDecodeDst ) result += "VideoDecodeDst | "; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) if ( value & BufferUsageFlagBits2KHR::eVideoEncodeDst ) result += "VideoEncodeDst | "; if ( value & BufferUsageFlagBits2KHR::eVideoEncodeSrc ) result += "VideoEncodeSrc | "; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ if ( value & BufferUsageFlagBits2KHR::eShaderDeviceAddress ) result += "ShaderDeviceAddress | "; if ( value & BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly ) @@ -4549,6 +4547,7 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eSetDescriptorBufferOffsetsInfoEXT: return "SetDescriptorBufferOffsetsInfoEXT"; case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT: return "BindDescriptorBufferEmbeddedSamplersInfoEXT"; case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV"; + case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV"; case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV: return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } @@ -8867,10 +8866,8 @@ namespace VULKAN_HPP_NAMESPACE case BufferUsageFlagBits2KHR::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT"; case BufferUsageFlagBits2KHR::eVideoDecodeSrc: return "VideoDecodeSrc"; case BufferUsageFlagBits2KHR::eVideoDecodeDst: return "VideoDecodeDst"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) case BufferUsageFlagBits2KHR::eVideoEncodeDst: return "VideoEncodeDst"; case BufferUsageFlagBits2KHR::eVideoEncodeSrc: return "VideoEncodeSrc"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ case BufferUsageFlagBits2KHR::eShaderDeviceAddress: return "ShaderDeviceAddress"; case BufferUsageFlagBits2KHR::eAccelerationStructureBuildInputReadOnly: return "AccelerationStructureBuildInputReadOnly"; case BufferUsageFlagBits2KHR::eAccelerationStructureStorage: return "AccelerationStructureStorage"; -- cgit v1.2.3