From 6578bfcc889fbb308efa03fabdd10eec05c0b9a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20S=C3=BC=C3=9Fenbach?= Date: Tue, 21 Jan 2025 10:53:23 +0100 Subject: [PATCH] Update Vulkan-Headers to v1.4.305 (#2049) --- Vulkan-Headers | 2 +- vulkan/vulkan.cppm | 50 +++- vulkan/vulkan.hpp | 119 +++++++-- vulkan/vulkan_enums.hpp | 55 ++-- vulkan/vulkan_extension_inspection.hpp | 30 ++- vulkan/vulkan_format_traits.hpp | 2 +- vulkan/vulkan_funcs.hpp | 2 +- vulkan/vulkan_handles.hpp | 16 +- vulkan/vulkan_hash.hpp | 54 +++- vulkan/vulkan_hpp_macros.hpp | 2 +- vulkan/vulkan_raii.hpp | 2 +- vulkan/vulkan_shared.hpp | 2 +- vulkan/vulkan_static_assertions.hpp | 45 +++- vulkan/vulkan_structs.hpp | 352 +++++++++++++++++++++++-- vulkan/vulkan_to_string.hpp | 39 ++- 15 files changed, 673 insertions(+), 99 deletions(-) diff --git a/Vulkan-Headers b/Vulkan-Headers index d4a196d8c..a03d2f6d5 160000 --- a/Vulkan-Headers +++ b/Vulkan-Headers @@ -1 +1 @@ -Subproject commit d4a196d8c84e032d27f999adcea3075517c1c97f +Subproject commit a03d2f6d5753b365d704d58161825890baad0755 diff --git a/vulkan/vulkan.cppm b/vulkan/vulkan.cppm index ec2c6700c..ed7993b3f 100644 --- a/vulkan/vulkan.cppm +++ b/vulkan/vulkan.cppm @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -919,6 +919,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeEXT; using VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoTypeEXT; + //=== VK_KHR_maintenance8 === + using VULKAN_HPP_NAMESPACE::AccessFlagBits3KHR; + using VULKAN_HPP_NAMESPACE::AccessFlags3KHR; + //=== VK_EXT_depth_clamp_control === using VULKAN_HPP_NAMESPACE::DepthClampModeEXT; @@ -2638,6 +2642,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsExtensionName; using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsSpecVersion; + //=== VK_KHR_maintenance8 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance8ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance8SpecVersion; + //=== VK_MESA_image_alignment_control === using VULKAN_HPP_NAMESPACE::MESAImageAlignmentControlExtensionName; using VULKAN_HPP_NAMESPACE::MESAImageAlignmentControlSpecVersion; @@ -2654,6 +2662,14 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2ExtensionName; using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2SpecVersion; + //=== VK_ARM_pipeline_opacity_micromap === + using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapExtensionName; + using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapSpecVersion; + + //=== VK_KHR_depth_clamp_zero_one === + using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneSpecVersion; + //=== VK_EXT_vertex_attribute_robustness === using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName; using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion; @@ -4316,9 +4332,6 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE; using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - //=== VK_EXT_depth_clamp_zero_one === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT; - //=== VK_EXT_non_seamless_cube_map === using VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; @@ -4654,6 +4667,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT; using VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT; + //=== VK_KHR_maintenance8 === + using VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR; + //=== VK_MESA_image_alignment_control === using VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA; using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA; @@ -4673,6 +4690,13 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV; using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV; + //=== VK_ARM_pipeline_opacity_micromap === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM; + + //=== VK_KHR_depth_clamp_zero_one === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR; + //=== VK_EXT_vertex_attribute_robustness === using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; @@ -7671,10 +7695,6 @@ export namespace std template <> struct hash; - //=== VK_EXT_depth_clamp_zero_one === - template <> - struct hash; - //=== VK_EXT_non_seamless_cube_map === template <> struct hash; @@ -8211,6 +8231,12 @@ export namespace std template <> struct hash; + //=== VK_KHR_maintenance8 === + template <> + struct hash; + template <> + struct hash; + //=== VK_MESA_image_alignment_control === template <> struct hash; @@ -8241,6 +8267,14 @@ export namespace std template <> struct hash; + //=== VK_ARM_pipeline_opacity_micromap === + template <> + struct hash; + + //=== VK_KHR_depth_clamp_zero_one === + template <> + struct hash; + //=== VK_EXT_vertex_attribute_robustness === template <> struct hash; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index bc6e81462..b3a6571e5 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -63,7 +63,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 304, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 305, "Wrong VK_HEADER_VERSION!" ); // includes through some other header // this results in major(x) being resolved to gnu_dev_major(x) @@ -8837,6 +8837,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsExtensionName = VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsSpecVersion = VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION; + //=== VK_KHR_maintenance8 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8ExtensionName = VK_KHR_MAINTENANCE_8_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8SpecVersion = VK_KHR_MAINTENANCE_8_SPEC_VERSION; + //=== VK_MESA_image_alignment_control === VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlExtensionName = VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlSpecVersion = VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION; @@ -8853,6 +8857,14 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2ExtensionName = VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2SpecVersion = VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION; + //=== VK_ARM_pipeline_opacity_micromap === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapExtensionName = VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapSpecVersion = VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION; + + //=== VK_KHR_depth_clamp_zero_one === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneExtensionName = VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneSpecVersion = VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION; + //=== VK_EXT_vertex_attribute_robustness === 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; @@ -15482,25 +15494,6 @@ namespace VULKAN_HPP_NAMESPACE }; }; - //=== VK_EXT_depth_clamp_zero_one === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - //=== VK_EXT_non_seamless_cube_map === template <> struct StructExtends @@ -17447,6 +17440,52 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_KHR_maintenance8 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_MESA_image_alignment_control === template <> struct StructExtends @@ -17568,6 +17607,44 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_ARM_pipeline_opacity_micromap === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_depth_clamp_zero_one === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_vertex_attribute_robustness === template <> struct StructExtends diff --git a/vulkan/vulkan_enums.hpp b/vulkan/vulkan_enums.hpp index f879bff87..efd6de5d7 100644 --- a/vulkan/vulkan_enums.hpp +++ b/vulkan/vulkan_enums.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -1352,7 +1352,6 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, eDescriptorSetBindingReferenceVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE, eDescriptorSetLayoutHostMappingInfoVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE, - ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT, ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, ePhysicalDeviceRenderPassStripedFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, ePhysicalDeviceRenderPassStripedPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM, @@ -1538,6 +1537,8 @@ namespace VULKAN_HPP_NAMESPACE eIndirectExecutionSetShaderLayoutInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT, eGeneratedCommandsPipelineInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT, eGeneratedCommandsShaderInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT, + ePhysicalDeviceMaintenance8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR, + eMemoryBarrierAccessFlags3KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR, ePhysicalDeviceImageAlignmentControlFeaturesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, ePhysicalDeviceImageAlignmentControlPropertiesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA, eImageAlignmentControlCreateInfoMESA = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA, @@ -1548,6 +1549,9 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceCooperativeMatrix2FeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV, eCooperativeMatrixFlexibleDimensionsPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV, ePhysicalDeviceCooperativeMatrix2PropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV, + ePhysicalDevicePipelineOpacityMicromapFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM, + 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 }; @@ -2733,8 +2737,9 @@ namespace VULKAN_HPP_NAMESPACE enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags { - eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, - eExternallySynchronizedEXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT + eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, + eExternallySynchronizedEXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT, + eInternallySynchronizedMergeKHR = VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR }; using PipelineCacheCreateFlags = Flags; @@ -2743,7 +2748,8 @@ namespace VULKAN_HPP_NAMESPACE struct FlagTraits { static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = PipelineCacheCreateFlagBits::eExternallySynchronized; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = + PipelineCacheCreateFlagBits::eExternallySynchronized | PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR; }; enum class BlendFactor @@ -3539,12 +3545,13 @@ namespace VULKAN_HPP_NAMESPACE enum class DependencyFlagBits : VkDependencyFlags { - eByRegion = VK_DEPENDENCY_BY_REGION_BIT, - eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT, - eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR, - eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT, - eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR, - eFeedbackLoopEXT = VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT + eByRegion = VK_DEPENDENCY_BY_REGION_BIT, + eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT, + eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR, + eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT, + eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR, + eFeedbackLoopEXT = VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT, + eQueueFamilyOwnershipTransferUseAllStagesKHR = VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR }; using DependencyFlags = Flags; @@ -3553,8 +3560,9 @@ namespace VULKAN_HPP_NAMESPACE struct FlagTraits { static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DependencyFlags allFlags = - DependencyFlagBits::eByRegion | DependencyFlagBits::eDeviceGroup | DependencyFlagBits::eViewLocal | DependencyFlagBits::eFeedbackLoopEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DependencyFlags allFlags = DependencyFlagBits::eByRegion | DependencyFlagBits::eDeviceGroup | + DependencyFlagBits::eViewLocal | DependencyFlagBits::eFeedbackLoopEXT | + DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR; }; enum class FramebufferCreateFlagBits : VkFramebufferCreateFlags @@ -4665,6 +4673,7 @@ namespace VULKAN_HPP_NAMESPACE eDepthStencilAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, eDescriptorBufferEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT, + eDisallowOpacityMicromapARM = VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM, eCaptureDataKHR = VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR, eIndirectBindableEXT = VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT }; @@ -4694,8 +4703,8 @@ namespace VULKAN_HPP_NAMESPACE PipelineCreateFlagBits2::eRayTracingAllowMotionNV | PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR | PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT | PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT | - PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV | PipelineCreateFlagBits2::eDescriptorBufferEXT | PipelineCreateFlagBits2::eCaptureDataKHR | - PipelineCreateFlagBits2::eIndirectBindableEXT; + PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV | PipelineCreateFlagBits2::eDescriptorBufferEXT | + PipelineCreateFlagBits2::eDisallowOpacityMicromapARM | PipelineCreateFlagBits2::eCaptureDataKHR | PipelineCreateFlagBits2::eIndirectBindableEXT; }; enum class BufferUsageFlagBits2 : VkBufferUsageFlags2 @@ -7686,6 +7695,22 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer | IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer; }; + //=== VK_KHR_maintenance8 === + + enum class AccessFlagBits3KHR : VkAccessFlags3KHR + { + eNone = VK_ACCESS_3_NONE_KHR + }; + + using AccessFlags3KHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags3KHR allFlags = AccessFlagBits3KHR::eNone; + }; + //=== VK_EXT_depth_clamp_control === enum class DepthClampModeEXT diff --git a/vulkan/vulkan_extension_inspection.hpp b/vulkan/vulkan_extension_inspection.hpp index 05365bfb8..d863e7475 100644 --- a/vulkan/vulkan_extension_inspection.hpp +++ b/vulkan/vulkan_extension_inspection.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -454,10 +454,13 @@ namespace VULKAN_HPP_NAMESPACE "VK_EXT_shader_replicated_composites", "VK_NV_ray_tracing_validation", "VK_EXT_device_generated_commands", + "VK_KHR_maintenance8", "VK_MESA_image_alignment_control", "VK_EXT_depth_clamp_control", "VK_HUAWEI_hdr_vivid", "VK_NV_cooperative_matrix2", + "VK_ARM_pipeline_opacity_micromap", + "VK_KHR_depth_clamp_zero_one", "VK_EXT_vertex_attribute_robustness" }; return deviceExtensions; @@ -2374,6 +2377,7 @@ namespace VULKAN_HPP_NAMESPACE "VK_KHR_buffer_device_address", "VK_KHR_maintenance5", } } } } }, + { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } }, { "VK_MESA_image_alignment_control", { { "VK_VERSION_1_0", { { @@ -2401,6 +2405,17 @@ namespace VULKAN_HPP_NAMESPACE { { "VK_KHR_cooperative_matrix", } } } } }, + { "VK_ARM_pipeline_opacity_micromap", + { { "VK_VERSION_1_0", + { { + "VK_EXT_opacity_micromap", + } } } } }, + { "VK_KHR_depth_clamp_zero_one", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, { "VK_EXT_vertex_attribute_robustness", { { "VK_VERSION_1_0", { { @@ -2543,6 +2558,7 @@ namespace VULKAN_HPP_NAMESPACE { "VK_EXT_load_store_op_none", "VK_KHR_load_store_op_none" }, { "VK_KHR_maintenance4", "VK_VERSION_1_3" }, { "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" }, + { "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" }, { "VK_EXT_pipeline_protected_access", "VK_VERSION_1_4" }, { "VK_KHR_maintenance5", "VK_VERSION_1_4" }, { "VK_KHR_vertex_attribute_divisor", "VK_VERSION_1_4" }, @@ -3012,6 +3028,10 @@ namespace VULKAN_HPP_NAMESPACE { return "VK_VERSION_1_4"; } + if ( extension == "VK_EXT_depth_clamp_zero_one" ) + { + return "VK_KHR_depth_clamp_zero_one"; + } if ( extension == "VK_EXT_pipeline_protected_access" ) { return "VK_VERSION_1_4"; @@ -3264,9 +3284,10 @@ namespace VULKAN_HPP_NAMESPACE ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) || - ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_EXT_device_generated_commands" ) || + ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || - ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_EXT_vertex_attribute_robustness" ); + ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) || + ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" ); } VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ) @@ -3376,7 +3397,8 @@ namespace VULKAN_HPP_NAMESPACE ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_VALVE_mutable_descriptor_type" ) || ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) || - ( extension == "VK_KHR_shader_subgroup_rotate" ) || ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) || + ( extension == "VK_KHR_shader_subgroup_rotate" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) || + ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ); diff --git a/vulkan/vulkan_format_traits.hpp b/vulkan/vulkan_format_traits.hpp index 75d9d80e9..5224e6c34 100644 --- a/vulkan/vulkan_format_traits.hpp +++ b/vulkan/vulkan_format_traits.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // diff --git a/vulkan/vulkan_funcs.hpp b/vulkan/vulkan_funcs.hpp index 753b16556..81dc53b32 100644 --- a/vulkan/vulkan_funcs.hpp +++ b/vulkan/vulkan_funcs.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // diff --git a/vulkan/vulkan_handles.hpp b/vulkan/vulkan_handles.hpp index ea9837523..eac2a045e 100644 --- a/vulkan/vulkan_handles.hpp +++ b/vulkan/vulkan_handles.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -1618,9 +1618,6 @@ namespace VULKAN_HPP_NAMESPACE struct DescriptorSetBindingReferenceVALVE; struct DescriptorSetLayoutHostMappingInfoVALVE; - //=== VK_EXT_depth_clamp_zero_one === - struct PhysicalDeviceDepthClampZeroOneFeaturesEXT; - //=== VK_EXT_non_seamless_cube_map === struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; @@ -1956,6 +1953,10 @@ namespace VULKAN_HPP_NAMESPACE struct GeneratedCommandsShaderInfoEXT; struct WriteIndirectExecutionSetShaderEXT; + //=== VK_KHR_maintenance8 === + struct PhysicalDeviceMaintenance8FeaturesKHR; + struct MemoryBarrierAccessFlags3KHR; + //=== VK_MESA_image_alignment_control === struct PhysicalDeviceImageAlignmentControlFeaturesMESA; struct PhysicalDeviceImageAlignmentControlPropertiesMESA; @@ -1975,6 +1976,13 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceCooperativeMatrix2FeaturesNV; struct PhysicalDeviceCooperativeMatrix2PropertiesNV; + //=== VK_ARM_pipeline_opacity_micromap === + struct PhysicalDevicePipelineOpacityMicromapFeaturesARM; + + //=== VK_KHR_depth_clamp_zero_one === + struct PhysicalDeviceDepthClampZeroOneFeaturesKHR; + using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR; + //=== VK_EXT_vertex_attribute_robustness === struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; diff --git a/vulkan/vulkan_hash.hpp b/vulkan/vulkan_hash.hpp index 0f54c3fa1..d97a92b5d 100644 --- a/vulkan/vulkan_hash.hpp +++ b/vulkan/vulkan_hash.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -7060,6 +7060,20 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR const & memoryBarrierAccessFlags3KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.srcAccessMask3 ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.dstAccessMask3 ); + return seed; + } + }; + template <> struct hash { @@ -8450,15 +8464,15 @@ namespace std }; template <> - struct hash + struct hash { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const & physicalDeviceDepthClampZeroOneFeaturesEXT ) const + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR const & physicalDeviceDepthClampZeroOneFeaturesKHR ) const VULKAN_HPP_NOEXCEPT { std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.depthClampZeroOne ); return seed; } }; @@ -10431,6 +10445,20 @@ namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR const & physicalDeviceMaintenance8FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.maintenance8 ); + return seed; + } + }; + template <> struct hash { @@ -11062,6 +11090,20 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM const & physicalDevicePipelineOpacityMicromapFeaturesARM ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.pipelineOpacityMicromap ); + return seed; + } + }; + template <> struct hash { diff --git a/vulkan/vulkan_hpp_macros.hpp b/vulkan/vulkan_hpp_macros.hpp index aba3b9aa9..a218f7256 100644 --- a/vulkan/vulkan_hpp_macros.hpp +++ b/vulkan/vulkan_hpp_macros.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp index af97bc57e..81e095328 100644 --- a/vulkan/vulkan_raii.hpp +++ b/vulkan/vulkan_raii.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // diff --git a/vulkan/vulkan_shared.hpp b/vulkan/vulkan_shared.hpp index 7b96b6c39..ab37dd973 100644 --- a/vulkan/vulkan_shared.hpp +++ b/vulkan/vulkan_shared.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // diff --git a/vulkan/vulkan_static_assertions.hpp b/vulkan/vulkan_static_assertions.hpp index 108374c0d..ffcf52ec1 100644 --- a/vulkan/vulkan_static_assertions.hpp +++ b/vulkan/vulkan_static_assertions.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -6550,15 +6550,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "DescriptorSetLayoutHostMappingInfoVALVE is not nothrow_move_constructible!" ); -//=== VK_EXT_depth_clamp_zero_one === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClampZeroOneFeaturesEXT ), - "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, - "PhysicalDeviceDepthClampZeroOneFeaturesEXT is not nothrow_move_constructible!" ); - //=== VK_EXT_non_seamless_cube_map === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT ) == @@ -8093,6 +8084,21 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "WriteIndirectExecutionSetShaderEXT is not nothrow_move_constructible!" ); +//=== VK_KHR_maintenance8 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance8FeaturesKHR ), + "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, + "PhysicalDeviceMaintenance8FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR ) == sizeof( VkMemoryBarrierAccessFlags3KHR ), + "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, + "MemoryBarrierAccessFlags3KHR is not nothrow_move_constructible!" ); + //=== VK_MESA_image_alignment_control === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA ) == @@ -8180,6 +8186,25 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceCooperativeMatrix2PropertiesNV is not nothrow_move_constructible!" ); +//=== VK_ARM_pipeline_opacity_micromap === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM ) == + sizeof( VkPhysicalDevicePipelineOpacityMicromapFeaturesARM ), + "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, + "PhysicalDevicePipelineOpacityMicromapFeaturesARM is not nothrow_move_constructible!" ); + +//=== VK_KHR_depth_clamp_zero_one === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR ) == sizeof( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR ), + "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, + "PhysicalDeviceDepthClampZeroOneFeaturesKHR is not nothrow_move_constructible!" ); + //=== VK_EXT_vertex_attribute_robustness === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT ) == diff --git a/vulkan/vulkan_structs.hpp b/vulkan/vulkan_structs.hpp index d0fbf2fb4..878aafa00 100644 --- a/vulkan/vulkan_structs.hpp +++ b/vulkan/vulkan_structs.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -54155,6 +54155,115 @@ namespace VULKAN_HPP_NAMESPACE using Type = MemoryBarrier; }; + struct MemoryBarrierAccessFlags3KHR + { + using NativeType = VkMemoryBarrierAccessFlags3KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrierAccessFlags3KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryBarrierAccessFlags3KHR( VULKAN_HPP_NAMESPACE::AccessFlags3KHR srcAccessMask3_ = {}, + VULKAN_HPP_NAMESPACE::AccessFlags3KHR dstAccessMask3_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcAccessMask3{ srcAccessMask3_ } + , dstAccessMask3{ dstAccessMask3_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryBarrierAccessFlags3KHR( MemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryBarrierAccessFlags3KHR( VkMemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryBarrierAccessFlags3KHR( *reinterpret_cast( &rhs ) ) + { + } + + MemoryBarrierAccessFlags3KHR & operator=( MemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryBarrierAccessFlags3KHR & operator=( VkMemoryBarrierAccessFlags3KHR 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 MemoryBarrierAccessFlags3KHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR & setSrcAccessMask3( VULKAN_HPP_NAMESPACE::AccessFlags3KHR srcAccessMask3_ ) VULKAN_HPP_NOEXCEPT + { + srcAccessMask3 = srcAccessMask3_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR & setDstAccessMask3( VULKAN_HPP_NAMESPACE::AccessFlags3KHR dstAccessMask3_ ) VULKAN_HPP_NOEXCEPT + { + dstAccessMask3 = dstAccessMask3_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryBarrierAccessFlags3KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryBarrierAccessFlags3KHR &() 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, srcAccessMask3, dstAccessMask3 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryBarrierAccessFlags3KHR const & ) const = default; +#else + bool operator==( MemoryBarrierAccessFlags3KHR 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 ) && ( srcAccessMask3 == rhs.srcAccessMask3 ) && ( dstAccessMask3 == rhs.dstAccessMask3 ); +# endif + } + + bool operator!=( MemoryBarrierAccessFlags3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryBarrierAccessFlags3KHR; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::AccessFlags3KHR srcAccessMask3 = {}; + VULKAN_HPP_NAMESPACE::AccessFlags3KHR dstAccessMask3 = {}; + }; + + template <> + struct CppType + { + using Type = MemoryBarrierAccessFlags3KHR; + }; + struct MemoryDedicatedAllocateInfo { using NativeType = VkMemoryDedicatedAllocateInfo; @@ -64341,45 +64450,45 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceDepthClampControlFeaturesEXT; }; - struct PhysicalDeviceDepthClampZeroOneFeaturesEXT + struct PhysicalDeviceDepthClampZeroOneFeaturesKHR { - using NativeType = VkPhysicalDeviceDepthClampZeroOneFeaturesEXT; + using NativeType = VkPhysicalDeviceDepthClampZeroOneFeaturesKHR; static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR; #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampZeroOne_ = {}, + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 depthClampZeroOne_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } , depthClampZeroOne{ depthClampZeroOne_ } { } - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesEXT( PhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesKHR( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - PhysicalDeviceDepthClampZeroOneFeaturesEXT( VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDepthClampZeroOneFeaturesEXT( *reinterpret_cast( &rhs ) ) + PhysicalDeviceDepthClampZeroOneFeaturesKHR( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDepthClampZeroOneFeaturesKHR( *reinterpret_cast( &rhs ) ) { } - PhysicalDeviceDepthClampZeroOneFeaturesEXT & operator=( PhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + PhysicalDeviceDepthClampZeroOneFeaturesKHR & operator=( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - PhysicalDeviceDepthClampZeroOneFeaturesEXT & operator=( VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + PhysicalDeviceDepthClampZeroOneFeaturesKHR & operator=( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR 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 PhysicalDeviceDepthClampZeroOneFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT { pNext = pNext_; return *this; } - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesEXT & + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR & setDepthClampZeroOne( VULKAN_HPP_NAMESPACE::Bool32 depthClampZeroOne_ ) VULKAN_HPP_NOEXCEPT { depthClampZeroOne = depthClampZeroOne_; @@ -64387,14 +64496,14 @@ namespace VULKAN_HPP_NAMESPACE } #endif /*VULKAN_HPP_NO_SETTERS*/ - operator VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } - operator VkPhysicalDeviceDepthClampZeroOneFeaturesEXT &() VULKAN_HPP_NOEXCEPT + operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR &() VULKAN_HPP_NOEXCEPT { - return *reinterpret_cast( this ); + return *reinterpret_cast( this ); } #if defined( VULKAN_HPP_USE_REFLECT ) @@ -64410,9 +64519,9 @@ namespace VULKAN_HPP_NAMESPACE #endif #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDepthClampZeroOneFeaturesEXT const & ) const = default; + auto operator<=>( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & ) const = default; #else - bool operator==( PhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator==( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { # if defined( VULKAN_HPP_USE_REFLECT ) return this->reflect() == rhs.reflect(); @@ -64421,24 +64530,26 @@ namespace VULKAN_HPP_NAMESPACE # endif } - bool operator!=( PhysicalDeviceDepthClampZeroOneFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + bool operator!=( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { return !operator==( rhs ); } #endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT; + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR; void * pNext = {}; VULKAN_HPP_NAMESPACE::Bool32 depthClampZeroOne = {}; }; template <> - struct CppType + struct CppType { - using Type = PhysicalDeviceDepthClampZeroOneFeaturesEXT; + using Type = PhysicalDeviceDepthClampZeroOneFeaturesKHR; }; + using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR; + struct PhysicalDeviceDepthClipControlFeaturesEXT { using NativeType = VkPhysicalDeviceDepthClipControlFeaturesEXT; @@ -77792,6 +77903,102 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceMaintenance7PropertiesKHR; }; + struct PhysicalDeviceMaintenance8FeaturesKHR + { + using NativeType = VkPhysicalDeviceMaintenance8FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance8FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance8FeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 maintenance8_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maintenance8{ maintenance8_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance8FeaturesKHR( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance8FeaturesKHR( VkPhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance8FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance8FeaturesKHR & operator=( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance8FeaturesKHR & operator=( VkPhysicalDeviceMaintenance8FeaturesKHR 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 PhysicalDeviceMaintenance8FeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance8FeaturesKHR & setMaintenance8( VULKAN_HPP_NAMESPACE::Bool32 maintenance8_ ) VULKAN_HPP_NOEXCEPT + { + maintenance8 = maintenance8_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMaintenance8FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance8FeaturesKHR &() 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, maintenance8 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance8FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance8FeaturesKHR 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 ) && ( maintenance8 == rhs.maintenance8 ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceMaintenance8FeaturesKHR; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 maintenance8 = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance8FeaturesKHR; + }; + struct PhysicalDeviceMapMemoryPlacedFeaturesEXT { using NativeType = VkPhysicalDeviceMapMemoryPlacedFeaturesEXT; @@ -81886,6 +82093,105 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; }; + struct PhysicalDevicePipelineOpacityMicromapFeaturesARM + { + using NativeType = VkPhysicalDevicePipelineOpacityMicromapFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineOpacityMicromapFeaturesARM( VULKAN_HPP_NAMESPACE::Bool32 pipelineOpacityMicromap_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineOpacityMicromap{ pipelineOpacityMicromap_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePipelineOpacityMicromapFeaturesARM( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineOpacityMicromapFeaturesARM( VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineOpacityMicromapFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineOpacityMicromapFeaturesARM & operator=( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineOpacityMicromapFeaturesARM & operator=( VkPhysicalDevicePipelineOpacityMicromapFeaturesARM 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 PhysicalDevicePipelineOpacityMicromapFeaturesARM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineOpacityMicromapFeaturesARM & + setPipelineOpacityMicromap( VULKAN_HPP_NAMESPACE::Bool32 pipelineOpacityMicromap_ ) VULKAN_HPP_NOEXCEPT + { + pipelineOpacityMicromap = pipelineOpacityMicromap_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM &() 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, pipelineOpacityMicromap ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineOpacityMicromapFeaturesARM 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 ) && ( pipelineOpacityMicromap == rhs.pipelineOpacityMicromap ); +# endif + } + + bool operator!=( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 pipelineOpacityMicromap = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineOpacityMicromapFeaturesARM; + }; + struct PhysicalDevicePipelinePropertiesFeaturesEXT { using NativeType = VkPhysicalDevicePipelinePropertiesFeaturesEXT; diff --git a/vulkan/vulkan_to_string.hpp b/vulkan/vulkan_to_string.hpp index e8d8eeb10..729e25fc2 100644 --- a/vulkan/vulkan_to_string.hpp +++ b/vulkan/vulkan_to_string.hpp @@ -1,4 +1,4 @@ -// Copyright 2015-2024 The Khronos Group Inc. +// Copyright 2015-2025 The Khronos Group Inc. // // SPDX-License-Identifier: Apache-2.0 OR MIT // @@ -685,6 +685,8 @@ namespace VULKAN_HPP_NAMESPACE std::string result; if ( value & PipelineCacheCreateFlagBits::eExternallySynchronized ) result += "ExternallySynchronized | "; + if ( value & PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR ) + result += "InternallySynchronizedMergeKHR | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -1085,6 +1087,8 @@ namespace VULKAN_HPP_NAMESPACE result += "ViewLocal | "; if ( value & DependencyFlagBits::eFeedbackLoopEXT ) result += "FeedbackLoopEXT | "; + if ( value & DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR ) + result += "QueueFamilyOwnershipTransferUseAllStagesKHR | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -1960,6 +1964,8 @@ namespace VULKAN_HPP_NAMESPACE result += "RayTracingDisplacementMicromapNV | "; if ( value & PipelineCreateFlagBits2::eDescriptorBufferEXT ) result += "DescriptorBufferEXT | "; + if ( value & PipelineCreateFlagBits2::eDisallowOpacityMicromapARM ) + result += "DisallowOpacityMicromapARM | "; if ( value & PipelineCreateFlagBits2::eCaptureDataKHR ) result += "CaptureDataKHR | "; if ( value & PipelineCreateFlagBits2::eIndirectBindableEXT ) @@ -3685,6 +3691,18 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } + //=== VK_KHR_maintenance8 === + + VULKAN_HPP_INLINE std::string to_string( AccessFlags3KHR value ) + { + if ( !value ) + return "None"; + + std::string result; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; + } + //======================= //=== ENUMs to_string === //======================= @@ -4599,7 +4617,6 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE: return "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE"; case StructureType::eDescriptorSetBindingReferenceVALVE: return "DescriptorSetBindingReferenceVALVE"; case StructureType::eDescriptorSetLayoutHostMappingInfoVALVE: return "DescriptorSetLayoutHostMappingInfoVALVE"; - case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT: return "PhysicalDeviceDepthClampZeroOneFeaturesEXT"; case StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT: return "PhysicalDeviceNonSeamlessCubeMapFeaturesEXT"; case StructureType::ePhysicalDeviceRenderPassStripedFeaturesARM: return "PhysicalDeviceRenderPassStripedFeaturesARM"; case StructureType::ePhysicalDeviceRenderPassStripedPropertiesARM: return "PhysicalDeviceRenderPassStripedPropertiesARM"; @@ -4780,6 +4797,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eIndirectExecutionSetShaderLayoutInfoEXT: return "IndirectExecutionSetShaderLayoutInfoEXT"; case StructureType::eGeneratedCommandsPipelineInfoEXT: return "GeneratedCommandsPipelineInfoEXT"; case StructureType::eGeneratedCommandsShaderInfoEXT: return "GeneratedCommandsShaderInfoEXT"; + case StructureType::ePhysicalDeviceMaintenance8FeaturesKHR: return "PhysicalDeviceMaintenance8FeaturesKHR"; + case StructureType::eMemoryBarrierAccessFlags3KHR: return "MemoryBarrierAccessFlags3KHR"; case StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA: return "PhysicalDeviceImageAlignmentControlFeaturesMESA"; case StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA: return "PhysicalDeviceImageAlignmentControlPropertiesMESA"; case StructureType::eImageAlignmentControlCreateInfoMESA: return "ImageAlignmentControlCreateInfoMESA"; @@ -4790,6 +4809,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV: return "PhysicalDeviceCooperativeMatrix2FeaturesNV"; case StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV: return "CooperativeMatrixFlexibleDimensionsPropertiesNV"; case StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV: return "PhysicalDeviceCooperativeMatrix2PropertiesNV"; + case StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM: return "PhysicalDevicePipelineOpacityMicromapFeaturesARM"; + case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR: return "PhysicalDeviceDepthClampZeroOneFeaturesKHR"; case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT: return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } @@ -5708,6 +5729,7 @@ namespace VULKAN_HPP_NAMESPACE switch ( value ) { case PipelineCacheCreateFlagBits::eExternallySynchronized: return "ExternallySynchronized"; + case PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR: return "InternallySynchronizedMergeKHR"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -6348,6 +6370,7 @@ namespace VULKAN_HPP_NAMESPACE case DependencyFlagBits::eDeviceGroup: return "DeviceGroup"; case DependencyFlagBits::eViewLocal: return "ViewLocal"; case DependencyFlagBits::eFeedbackLoopEXT: return "FeedbackLoopEXT"; + case DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR: return "QueueFamilyOwnershipTransferUseAllStagesKHR"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -7107,6 +7130,7 @@ namespace VULKAN_HPP_NAMESPACE case PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT: return "DepthStencilAttachmentFeedbackLoopEXT"; case PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; case PipelineCreateFlagBits2::eDescriptorBufferEXT: return "DescriptorBufferEXT"; + case PipelineCreateFlagBits2::eDisallowOpacityMicromapARM: return "DisallowOpacityMicromapARM"; case PipelineCreateFlagBits2::eCaptureDataKHR: return "CaptureDataKHR"; case PipelineCreateFlagBits2::eIndirectBindableEXT: return "IndirectBindableEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; @@ -9515,6 +9539,17 @@ namespace VULKAN_HPP_NAMESPACE } } + //=== VK_KHR_maintenance8 === + + VULKAN_HPP_INLINE std::string to_string( AccessFlagBits3KHR value ) + { + switch ( value ) + { + case AccessFlagBits3KHR::eNone: return "None"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } + } + //=== VK_EXT_depth_clamp_control === VULKAN_HPP_INLINE std::string to_string( DepthClampModeEXT value )