TheCloud/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2025-09-08 11:27:25 -04:00
Code Issues Packages Projects Releases Wiki Activity

Update Vulkan-Headers to v1.4.305 (#2049)

Browse Source
This commit is contained in:
Andreas Süßenbach 2025-01-21 10:53:23 +01:00 committed by GitHub
parent e7a8252006
commit 6578bfcc88
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 673 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit d4a196d8c84e032d27f999adcea3075517c1c97f
Subproject commit a03d2f6d5753b365d704d58161825890baad0755

50
vulkan/vulkan.cppm
View File

@ -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<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE>;
//=== VK_EXT_depth_clamp_zero_one ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT>;
//=== VK_EXT_non_seamless_cube_map ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT>;
@ -8211,6 +8231,12 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT>;
//=== VK_KHR_maintenance8 ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>;
//=== VK_MESA_image_alignment_control ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA>;
@ -8241,6 +8267,14 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV>;
//=== VK_ARM_pipeline_opacity_micromap ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>;
//=== VK_KHR_depth_clamp_zero_one ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR>;
//=== VK_EXT_vertex_attribute_robustness ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>;

119
vulkan/vulkan.hpp
View File

@ -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 <span>
#endif
static_assert( VK_HEADER_VERSION == 304, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 305, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> 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<PhysicalDeviceDepthClampZeroOneFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_non_seamless_cube_map ===
template <>
struct StructExtends<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, PhysicalDeviceFeatures2>
@ -17447,6 +17440,52 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_maintenance8 ===
template <>
struct StructExtends<PhysicalDeviceMaintenance8FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance8FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryBarrierAccessFlags3KHR, MemoryBarrier2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryBarrierAccessFlags3KHR, BufferMemoryBarrier2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryBarrierAccessFlags3KHR, ImageMemoryBarrier2>
{
enum
{
value = true
};
};
//=== VK_MESA_image_alignment_control ===
template <>
struct StructExtends<PhysicalDeviceImageAlignmentControlFeaturesMESA, PhysicalDeviceFeatures2>
@ -17568,6 +17607,44 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_ARM_pipeline_opacity_micromap ===
template <>
struct StructExtends<PhysicalDevicePipelineOpacityMicromapFeaturesARM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePipelineOpacityMicromapFeaturesARM, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_KHR_depth_clamp_zero_one ===
template <>
struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_vertex_attribute_robustness ===
template <>
struct StructExtends<PhysicalDeviceVertexAttributeRobustnessFeaturesEXT, PhysicalDeviceFeatures2>

55
vulkan/vulkan_enums.hpp
View File

@ -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<PipelineCacheCreateFlagBits>;
@ -2743,7 +2748,8 @@ namespace VULKAN_HPP_NAMESPACE
struct FlagTraits<PipelineCacheCreateFlagBits>
{
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<DependencyFlagBits>;
@ -3553,8 +3560,9 @@ namespace VULKAN_HPP_NAMESPACE
struct FlagTraits<DependencyFlagBits>
{
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<AccessFlagBits3KHR>;
template <>
struct FlagTraits<AccessFlagBits3KHR>
{
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

30
vulkan/vulkan_extension_inspection.hpp
View File

@ -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" );

2
vulkan/vulkan_format_traits.hpp
View File

@ -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
//

2
vulkan/vulkan_funcs.hpp
View File

@ -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
//

16
vulkan/vulkan_handles.hpp
View File

@ -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;

54
vulkan/vulkan_hash.hpp
View File

@ -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<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>
{
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<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo>
{
@ -8450,15 +8464,15 @@ namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT>
{
@ -11062,6 +11090,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>
{
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<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT>
{

2
vulkan/vulkan_hpp_macros.hpp
View File

@ -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
//

2
vulkan/vulkan_raii.hpp
View File

@ -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
//

2
vulkan/vulkan_shared.hpp
View File

@ -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
//

45
vulkan/vulkan_static_assertions.hpp
View File

@ -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<VULKAN_HPP_NAMESPACE::Descript
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE>::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<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT>::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<VULKAN_HPP_NAMESPACE::WriteInd
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT>::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<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR>::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<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>::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<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV>::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<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM>::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<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR>::value,
"PhysicalDeviceDepthClampZeroOneFeaturesKHR is not nothrow_move_constructible!" );
//=== VK_EXT_vertex_attribute_robustness ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT ) ==

352
vulkan/vulkan_structs.hpp
View File

@ -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<MemoryBarrierAccessFlags3KHR const *>( &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<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR const *>( &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<const VkMemoryBarrierAccessFlags3KHR *>( this );
}
operator VkMemoryBarrierAccessFlags3KHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryBarrierAccessFlags3KHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
VULKAN_HPP_NAMESPACE::AccessFlags3KHR const &,
VULKAN_HPP_NAMESPACE::AccessFlags3KHR const &>
# 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<StructureType, StructureType::eMemoryBarrierAccessFlags3KHR>
{
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<PhysicalDeviceDepthClampZeroOneFeaturesEXT const *>( &rhs ) )
PhysicalDeviceDepthClampZeroOneFeaturesKHR( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceDepthClampZeroOneFeaturesKHR( *reinterpret_cast<PhysicalDeviceDepthClampZeroOneFeaturesKHR const *>( &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<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT const *>( &rhs );
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR const *>( &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<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>( this );
return *reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>( this );
}
operator VkPhysicalDeviceDepthClampZeroOneFeaturesEXT &() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>( this );
return *reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>( 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<StructureType, StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesEXT>
struct CppType<StructureType, StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR>
{
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<PhysicalDeviceMaintenance8FeaturesKHR const *>( &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<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR const *>( &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<const VkPhysicalDeviceMaintenance8FeaturesKHR *>( this );
}
operator VkPhysicalDeviceMaintenance8FeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceMaintenance8FeaturesKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
# 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<StructureType, StructureType::ePhysicalDeviceMaintenance8FeaturesKHR>
{
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<PhysicalDevicePipelineOpacityMicromapFeaturesARM const *>( &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<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM const *>( &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<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>( this );
}
operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
# 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<StructureType, StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM>
{
using Type = PhysicalDevicePipelineOpacityMicromapFeaturesARM;
};
struct PhysicalDevicePipelinePropertiesFeaturesEXT
{
using NativeType = VkPhysicalDevicePipelinePropertiesFeaturesEXT;

39
vulkan/vulkan_to_string.hpp
View File

@ -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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( 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<uint32_t>( value ) ) + " )";
}
}
//=== VK_EXT_depth_clamp_control ===
VULKAN_HPP_INLINE std::string to_string( DepthClampModeEXT value )