organicmaps/Vulkan-Headers
13
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Headers.git synced 2025-04-10 14:51:30 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions

Merge branch 'KhronosGroup:main' into cxxmodules-tests

Browse source
This commit is contained in:
Jan Kuhlmann 2025-03-21 10:40:22 +01:00 • committed by GitHub
commit 5a4f3cd5a5
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 1889 additions and 1257 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
include/vulkan/vulkan.cppm
View file

@ -1555,6 +1555,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportSpecVersion;
//=== VK_KHR_shader_bfloat16 ===
using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16SpecVersion;
//=== VK_EXT_sample_locations ===
using VULKAN_HPP_NAMESPACE::EXTSampleLocationsExtensionName;
using VULKAN_HPP_NAMESPACE::EXTSampleLocationsSpecVersion;
@ -2734,6 +2738,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetExtensionName;
using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetSpecVersion;
//========================
//=== CONSTEXPR VALUEs ===
//========================
@ -3723,6 +3731,9 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD;
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV;
//=== VK_KHR_shader_bfloat16 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR;
//=== VK_EXT_sample_locations ===
using VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT;
using VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT;
@ -4402,11 +4413,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM;
using VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM;
//=== VK_QCOM_fragment_density_map_offset ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
//=== VK_NV_copy_memory_indirect ===
using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
@ -4820,6 +4826,15 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::SetPresentConfigNV;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
using VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT;
using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT;
using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
//===============
//=== HANDLEs ===
//===============
@ -5197,7 +5212,6 @@ export namespace VULKAN_HPP_NAMESPACE
//======================================
using VULKAN_HPP_NAMESPACE::getDeprecatedExtensions;
using VULKAN_HPP_NAMESPACE::getDeviceExtensions;
using VULKAN_HPP_NAMESPACE::getExtensionDepends;
using VULKAN_HPP_NAMESPACE::getExtensionDeprecatedBy;
using VULKAN_HPP_NAMESPACE::getExtensionObsoletedBy;
using VULKAN_HPP_NAMESPACE::getExtensionPromotedTo;
@ -6771,6 +6785,10 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>;
//=== VK_KHR_shader_bfloat16 ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>;
//=== VK_EXT_sample_locations ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>;
@ -7831,14 +7849,6 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>;
//=== VK_QCOM_fragment_density_map_offset ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>;
//=== VK_NV_copy_memory_indirect ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>;
@ -8505,6 +8515,16 @@ export namespace std
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>;
//=================================================================
//=== Required exports for VULKAN_HPP_NAMESPACE::StructureChain ===
//=================================================================

128
include/vulkan/vulkan.hpp
View file

@ -63,7 +63,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 310, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 311, "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)
@ -6219,6 +6219,13 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkGetMemoryMetalHandlePropertiesEXT( device, handleType, pHandle, pMemoryMetalHandleProperties );
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
void vkCmdEndRendering2EXT( VkCommandBuffer commandBuffer, const VkRenderingEndInfoEXT * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdEndRendering2EXT( commandBuffer, pRenderingEndInfo );
}
};
inline DispatchLoaderStatic & getDispatchLoaderStatic()
@ -7799,6 +7806,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportExtensionName = VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportSpecVersion = VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION;
//=== VK_KHR_shader_bfloat16 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16ExtensionName = VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16SpecVersion = VK_KHR_SHADER_BFLOAT16_SPEC_VERSION;
//=== VK_EXT_sample_locations ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsExtensionName = VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsSpecVersion = VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION;
@ -8973,6 +8984,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringSpecVersion = VK_NV_PRESENT_METERING_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION;
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
@ -12193,6 +12208,25 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_shader_bfloat16 ===
template <>
struct StructExtends<PhysicalDeviceShaderBfloat16FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderBfloat16FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_sample_locations ===
template <>
struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier>
@ -15672,43 +15706,6 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_QCOM_fragment_density_map_offset ===
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<SubpassFragmentDensityMapOffsetEndInfoQCOM, SubpassEndInfo>
{
enum
{
value = true
};
};
//=== VK_NV_copy_memory_indirect ===
template <>
struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesNV, PhysicalDeviceFeatures2>
@ -18004,6 +18001,52 @@ namespace VULKAN_HPP_NAMESPACE
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassFragmentDensityMapOffsetEndInfoEXT, SubpassEndInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<RenderPassFragmentDensityMapOffsetEndInfoEXT, RenderingEndInfoEXT>
{
enum
{
value = true
};
};
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
namespace detail
@ -19335,6 +19378,9 @@ namespace VULKAN_HPP_NAMESPACE
PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0;
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0;
public:
DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
@ -20877,6 +20923,9 @@ namespace VULKAN_HPP_NAMESPACE
vkGetMemoryMetalHandlePropertiesEXT =
PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandlePropertiesEXT" ) );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2EXT" ) );
}
void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
@ -22044,6 +22093,9 @@ namespace VULKAN_HPP_NAMESPACE
vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) );
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) );
}
template <typename DynamicLoader>

69
include/vulkan/vulkan_core.h
View file

@ -69,7 +69,7 @@ extern "C" {
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file
#define VK_HEADER_VERSION 310
#define VK_HEADER_VERSION 311
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -658,6 +658,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX = 1000134004,
#endif
VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR = 1000141000,
VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
@ -1024,9 +1025,6 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM = 1000424002,
VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003,
VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001,
VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000,
@ -1243,6 +1241,10 @@ typedef enum VkStructureType {
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001,
#endif
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT = 1000425000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001,
VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002,
VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = 1000619003,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
// VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a deprecated alias
@ -1453,6 +1455,9 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,
VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES,
@ -2502,14 +2507,15 @@ typedef enum VkImageCreateFlagBits {
VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000,
VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000,
VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000,
VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000,
VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000,
VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 0x00008000,
VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT,
VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkImageCreateFlagBits;
typedef VkFlags VkImageCreateFlags;
@ -10711,6 +10717,20 @@ typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
// VK_KHR_shader_bfloat16 is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_shader_bfloat16 1
#define VK_KHR_SHADER_BFLOAT16_SPEC_VERSION 1
#define VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME "VK_KHR_shader_bfloat16"
typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 shaderBFloat16Type;
VkBool32 shaderBFloat16DotProduct;
VkBool32 shaderBFloat16CooperativeMatrix;
} VkPhysicalDeviceShaderBfloat16FeaturesKHR;
// VK_KHR_relaxed_block_layout is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_relaxed_block_layout 1
#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
@ -12191,6 +12211,7 @@ typedef enum VkComponentTypeKHR {
VK_COMPONENT_TYPE_UINT16_KHR = 8,
VK_COMPONENT_TYPE_UINT32_KHR = 9,
VK_COMPONENT_TYPE_UINT64_KHR = 10,
VK_COMPONENT_TYPE_BFLOAT16_KHR = 1000141000,
VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000,
VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001,
VK_COMPONENT_TYPE_FLOAT_E4M3_NV = 1000491002,
@ -18882,26 +18903,32 @@ typedef struct VkRenderPassStripeSubmitInfoARM {
// VK_QCOM_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls.
#define VK_QCOM_fragment_density_map_offset 1
#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 2
#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 3
#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset"
typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 fragmentDensityMapOffset;
} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
VkStructureType sType;
void* pNext;
VkExtent2D fragmentDensityOffsetGranularity;
} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM {
typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
typedef struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT {
VkStructureType sType;
const void* pNext;
uint32_t fragmentDensityOffsetCount;
const VkOffset2D* pFragmentDensityOffsets;
} VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
} VkRenderPassFragmentDensityMapOffsetEndInfoEXT;
typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
@ -21386,6 +21413,24 @@ typedef struct VkPhysicalDevicePresentMeteringFeaturesNV {
// VK_EXT_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_fragment_density_map_offset 1
#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1
#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_EXT_fragment_density_map_offset"
typedef struct VkRenderingEndInfoEXT {
VkStructureType sType;
const void* pNext;
} VkRenderingEndInfoEXT;
typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2EXT)(VkCommandBuffer commandBuffer, const VkRenderingEndInfoEXT* pRenderingEndInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT(
VkCommandBuffer commandBuffer,
const VkRenderingEndInfoEXT* pRenderingEndInfo);
#endif
// VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_acceleration_structure 1
#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13

21
include/vulkan/vulkan_enums.hpp
View file

@ -988,6 +988,7 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eAttachmentSampleCountInfoAMD = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD,
eAttachmentSampleCountInfoNV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV,
ePhysicalDeviceShaderBfloat16FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR,
eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,
eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
@ -1360,9 +1361,6 @@ namespace VULKAN_HPP_NAMESPACE
eRenderPassStripeBeginInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM,
eRenderPassStripeInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM,
eRenderPassStripeSubmitInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM,
ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
eSubpassFragmentDensityMapOffsetEndInfoQCOM = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
ePhysicalDeviceCopyMemoryIndirectFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV,
ePhysicalDeviceCopyMemoryIndirectPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV,
ePhysicalDeviceMemoryDecompressionFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV,
@ -1587,8 +1585,15 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT,
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eSetPresentConfigNV = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV,
ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV
ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,
ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,
ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
eRenderPassFragmentDensityMapOffsetEndInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,
eSubpassFragmentDensityMapOffsetEndInfoQCOM = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
eRenderingEndInfoEXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT
};
// wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html
@ -2087,8 +2092,9 @@ namespace VULKAN_HPP_NAMESPACE
eDescriptorBufferCaptureReplayEXT = VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT,
eMultisampledRenderToSingleSampledEXT = VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT,
e2DViewCompatibleEXT = VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT,
eFragmentDensityMapOffsetQCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM,
eVideoProfileIndependentKHR = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR
eVideoProfileIndependentKHR = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR,
eFragmentDensityMapOffsetEXT = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT,
eFragmentDensityMapOffsetQCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM
};
// wrapper using for bitmask VkImageCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlags.html
@ -2105,7 +2111,7 @@ namespace VULKAN_HPP_NAMESPACE
ImageCreateFlagBits::eProtected | ImageCreateFlagBits::eDisjoint | ImageCreateFlagBits::eCornerSampledNV |
ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT | ImageCreateFlagBits::eSubsampledEXT | ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT |
ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT | ImageCreateFlagBits::e2DViewCompatibleEXT |
ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM | ImageCreateFlagBits::eVideoProfileIndependentKHR;
ImageCreateFlagBits::eVideoProfileIndependentKHR | ImageCreateFlagBits::eFragmentDensityMapOffsetEXT;
};
// wrapper class for enum VkImageTiling, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageTiling.html
@ -8152,6 +8158,7 @@ namespace VULKAN_HPP_NAMESPACE
eUint16 = VK_COMPONENT_TYPE_UINT16_KHR,
eUint32 = VK_COMPONENT_TYPE_UINT32_KHR,
eUint64 = VK_COMPONENT_TYPE_UINT64_KHR,
eBfloat16 = VK_COMPONENT_TYPE_BFLOAT16_KHR,
eSint8PackedNV = VK_COMPONENT_TYPE_SINT8_PACKED_NV,
eUint8PackedNV = VK_COMPONENT_TYPE_UINT8_PACKED_NV,
eFloatE4M3NV = VK_COMPONENT_TYPE_FLOAT_E4M3_NV,

19
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -178,6 +178,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_AMD_shader_fragment_mask",
"VK_EXT_inline_uniform_block",
"VK_EXT_shader_stencil_export",
"VK_KHR_shader_bfloat16",
"VK_EXT_sample_locations",
"VK_KHR_relaxed_block_layout",
"VK_KHR_get_memory_requirements2",
@ -469,8 +470,9 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_depth_clamp_zero_one",
"VK_EXT_vertex_attribute_robustness",
#if defined( VK_ENABLE_BETA_EXTENSIONS )
"VK_NV_present_metering"
"VK_NV_present_metering",
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
"VK_EXT_fragment_density_map_offset"
};
return deviceExtensions;
}
@ -653,6 +655,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "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_QCOM_fragment_density_map_offset", "VK_EXT_fragment_density_map_offset" },
{ "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" },
@ -1126,6 +1129,10 @@ namespace VULKAN_HPP_NAMESPACE
{
return "VK_KHR_depth_clamp_zero_one";
}
if ( extension == "VK_QCOM_fragment_density_map_offset" )
{
return "VK_EXT_fragment_density_map_offset";
}
if ( extension == "VK_EXT_pipeline_protected_access" )
{
return "VK_VERSION_1_4";
@ -1241,8 +1248,8 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_AMDX_shader_enqueue" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|| ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) ||
( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_EXT_sample_locations" ) ||
( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_KHR_shader_bfloat16" ) ||
( extension == "VK_EXT_sample_locations" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_EXT_blend_operation_advanced" ) ||
( extension == "VK_NV_fragment_coverage_to_color" ) || ( extension == "VK_KHR_acceleration_structure" ) ||
( extension == "VK_KHR_ray_tracing_pipeline" ) || ( extension == "VK_KHR_ray_query" ) || ( extension == "VK_NV_framebuffer_mixed_samples" ) ||
@ -1392,7 +1399,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_present_metering" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
;
|| ( extension == "VK_EXT_fragment_density_map_offset" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
@ -1503,8 +1510,8 @@ namespace VULKAN_HPP_NAMESPACE
( 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_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_QCOM_fragment_density_map_offset" ) || ( 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" );
}

27
include/vulkan/vulkan_funcs.hpp
View file

@ -31501,5 +31501,32 @@ namespace VULKAN_HPP_NAMESPACE
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT * pRenderingEndInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdEndRendering2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingEndInfoEXT *>( pRenderingEndInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCmdEndRendering2EXT && "Function <vkCmdEndRendering2EXT> requires <VK_EXT_fragment_density_map_offset>" );
# endif
d.vkCmdEndRendering2EXT(
m_commandBuffer, reinterpret_cast<const VkRenderingEndInfoEXT *>( static_cast<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT *>( renderingEndInfo ) ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
} // namespace VULKAN_HPP_NAMESPACE
#endif

30
include/vulkan/vulkan_handles.hpp
View file

@ -949,6 +949,9 @@ namespace VULKAN_HPP_NAMESPACE
struct AttachmentSampleCountInfoAMD;
using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
//=== VK_KHR_shader_bfloat16 ===
struct PhysicalDeviceShaderBfloat16FeaturesKHR;
//=== VK_EXT_sample_locations ===
struct SampleLocationEXT;
struct SampleLocationsInfoEXT;
@ -1628,11 +1631,6 @@ namespace VULKAN_HPP_NAMESPACE
struct RenderPassStripeInfoARM;
struct RenderPassStripeSubmitInfoARM;
//=== VK_QCOM_fragment_density_map_offset ===
struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
struct SubpassFragmentDensityMapOffsetEndInfoQCOM;
//=== VK_NV_copy_memory_indirect ===
struct CopyMemoryIndirectCommandNV;
struct CopyMemoryToImageIndirectCommandNV;
@ -2046,6 +2044,15 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDevicePresentMeteringFeaturesNV;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
struct RenderingEndInfoEXT;
struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
struct RenderPassFragmentDensityMapOffsetEndInfoEXT;
using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT;
//===================================
//=== HANDLE forward declarations ===
//===================================
@ -7797,6 +7804,19 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_EXT_fragment_density_map_offset ===
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endRendering2EXT( const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT * pRenderingEndInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
{
return m_commandBuffer;

84
include/vulkan/vulkan_hash.hpp
View file

@ -9761,30 +9761,30 @@ namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & physicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) const
VULKAN_HPP_NOEXCEPT
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & physicalDeviceFragmentDensityMapOffsetFeaturesEXT )
const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.fragmentDensityMapOffset );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &
physicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & physicalDeviceFragmentDensityMapOffsetPropertiesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.fragmentDensityOffsetGranularity );
return seed;
}
};
@ -12371,6 +12371,22 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR const & physicalDeviceShaderBfloat16FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16Type );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16DotProduct );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16CooperativeMatrix );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
{
@ -15482,6 +15498,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT const & renderPassFragmentDensityMapOffsetEndInfoEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.fragmentDensityOffsetCount );
VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pFragmentDensityOffsets );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
{
@ -15675,6 +15706,18 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT const & renderingEndInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.pNext );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
{
@ -16407,21 +16450,6 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const & subpassFragmentDensityMapOffsetEndInfoQCOM ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount );
VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT>
{

25
include/vulkan/vulkan_raii.hpp
View file

@ -1843,6 +1843,9 @@ namespace VULKAN_HPP_NAMESPACE
vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) );
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) );
}
public:
@ -2790,6 +2793,9 @@ namespace VULKAN_HPP_NAMESPACE
PFN_dummy vkGetMemoryMetalHandleEXT_placeholder = 0;
PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0;
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0;
};
} // namespace detail
@ -7853,6 +7859,12 @@ namespace VULKAN_HPP_NAMESPACE
void executeGeneratedCommandsEXT( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,
const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_fragment_density_map_offset ===
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
void endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const
VULKAN_HPP_NOEXCEPT;
private:
VULKAN_HPP_NAMESPACE::Device m_device = {};
VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {};
@ -27213,6 +27225,19 @@ namespace VULKAN_HPP_NAMESPACE
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_fragment_density_map_offset ===
// wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
VULKAN_HPP_INLINE void
CommandBuffer::endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering2EXT && "Function <vkCmdEndRendering2EXT> requires <VK_EXT_fragment_density_map_offset>" );
getDispatcher()->vkCmdEndRendering2EXT(
static_cast<VkCommandBuffer>( m_commandBuffer ),
reinterpret_cast<const VkRenderingEndInfoEXT *>( static_cast<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT *>( renderingEndInfo ) ) );
}
//====================
//=== RAII Helpers ===
//====================

65
include/vulkan/vulkan_static_assertions.hpp
View file

@ -3611,6 +3611,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Attachme
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>::value,
"AttachmentSampleCountInfoAMD is not nothrow_move_constructible!" );
//=== VK_KHR_shader_bfloat16 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderBfloat16FeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
"PhysicalDeviceShaderBfloat16FeaturesKHR is not nothrow_move_constructible!" );
//=== VK_EXT_sample_locations ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
@ -6595,31 +6604,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPa
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>::value,
"RenderPassStripeSubmitInfoARM is not nothrow_move_constructible!" );
//=== VK_QCOM_fragment_density_map_offset ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) ==
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
"PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) ==
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
"PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM ) == sizeof( VkSubpassFragmentDensityMapOffsetEndInfoQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
"SubpassFragmentDensityMapOffsetEndInfoQCOM is not nothrow_move_constructible!" );
//=== VK_NV_copy_memory_indirect ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV ) == sizeof( VkCopyMemoryIndirectCommandNV ),
@ -8547,4 +8531,35 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
"PhysicalDevicePresentMeteringFeaturesNV is not nothrow_move_constructible!" );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_fragment_density_map_offset ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT ) == sizeof( VkRenderingEndInfoEXT ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value,
"RenderingEndInfoEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ) ==
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
"PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ) ==
sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
"PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT ) ==
sizeof( VkRenderPassFragmentDensityMapOffsetEndInfoEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
"RenderPassFragmentDensityMapOffsetEndInfoEXT is not nothrow_move_constructible!" );
#endif

634
include/vulkan/vulkan_structs.hpp
View file

@ -81768,49 +81768,49 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT;
};
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.html
struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.html
struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT
{
using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, fragmentDensityMapOffset{ fragmentDensityMapOffset_ }
{
}
VULKAN_HPP_CONSTEXPR
PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM( *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *>( &rhs ) )
PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const *>( &rhs ) )
{
}
PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
operator=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &
operator=( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM & operator=( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & operator=( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *>( &rhs );
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &
setFragmentDensityMapOffset( VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityMapOffset = fragmentDensityMapOffset_;
@ -81818,24 +81818,24 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
@ -81851,9 +81851,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & ) const = default;
auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
@ -81862,77 +81862,79 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapOffset = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>
{
using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
};
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM.html
struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.html
struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT
{
using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, fragmentDensityOffsetGranularity{ fragmentDensityOffsetGranularity_ }
{
}
VULKAN_HPP_CONSTEXPR
PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM( *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *>( &rhs ) )
PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( *reinterpret_cast<PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const *>( &rhs ) )
{
}
PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &
operator=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &
operator=( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM & operator=( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT & operator=( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *>( &rhs );
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const *>( &rhs );
return *this;
}
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>( this );
}
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
@ -81948,9 +81950,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & ) const = default;
auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
@ -81959,24 +81961,26 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Extent2D fragmentDensityOffsetGranularity = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>
{
using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
};
using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html
struct PhysicalDeviceFragmentDensityMapPropertiesEXT
@ -101106,6 +101110,141 @@ namespace VULKAN_HPP_NAMESPACE
using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
// wrapper struct for struct VkPhysicalDeviceShaderBfloat16FeaturesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderBfloat16FeaturesKHR.html
struct PhysicalDeviceShaderBfloat16FeaturesKHR
{
using NativeType = VkPhysicalDeviceShaderBfloat16FeaturesKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderBfloat16FeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16Type_ = {},
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16DotProduct_ = {},
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16CooperativeMatrix_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, shaderBFloat16Type{ shaderBFloat16Type_ }
, shaderBFloat16DotProduct{ shaderBFloat16DotProduct_ }
, shaderBFloat16CooperativeMatrix{ shaderBFloat16CooperativeMatrix_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderBfloat16FeaturesKHR( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceShaderBfloat16FeaturesKHR( VkPhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceShaderBfloat16FeaturesKHR( *reinterpret_cast<PhysicalDeviceShaderBfloat16FeaturesKHR const *>( &rhs ) )
{
}
PhysicalDeviceShaderBfloat16FeaturesKHR & operator=( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceShaderBfloat16FeaturesKHR & operator=( VkPhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR &
setShaderBFloat16Type( VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16Type_ ) VULKAN_HPP_NOEXCEPT
{
shaderBFloat16Type = shaderBFloat16Type_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR &
setShaderBFloat16DotProduct( VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16DotProduct_ ) VULKAN_HPP_NOEXCEPT
{
shaderBFloat16DotProduct = shaderBFloat16DotProduct_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR &
setShaderBFloat16CooperativeMatrix( VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16CooperativeMatrix_ ) VULKAN_HPP_NOEXCEPT
{
shaderBFloat16CooperativeMatrix = shaderBFloat16CooperativeMatrix_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceShaderBfloat16FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderBfloat16FeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderBfloat16FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderBfloat16FeaturesKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR *>( 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 &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, shaderBFloat16Type, shaderBFloat16DotProduct, shaderBFloat16CooperativeMatrix );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderBfloat16FeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderBfloat16FeaturesKHR 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 ) && ( shaderBFloat16Type == rhs.shaderBFloat16Type ) &&
( shaderBFloat16DotProduct == rhs.shaderBFloat16DotProduct ) && ( shaderBFloat16CooperativeMatrix == rhs.shaderBFloat16CooperativeMatrix );
# endif
}
bool operator!=( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16Type = {};
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16DotProduct = {};
VULKAN_HPP_NAMESPACE::Bool32 shaderBFloat16CooperativeMatrix = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR>
{
using Type = PhysicalDeviceShaderBfloat16FeaturesKHR;
};
// wrapper struct for struct VkPhysicalDeviceShaderClockFeaturesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html
struct PhysicalDeviceShaderClockFeaturesKHR
@ -127068,6 +127207,149 @@ namespace VULKAN_HPP_NAMESPACE
using Type = RenderPassFragmentDensityMapCreateInfoEXT;
};
// wrapper struct for struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassFragmentDensityMapOffsetEndInfoEXT.html
struct RenderPassFragmentDensityMapOffsetEndInfoEXT
{
using NativeType = VkRenderPassFragmentDensityMapOffsetEndInfoEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapOffsetEndInfoEXT( uint32_t fragmentDensityOffsetCount_ = {},
const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, fragmentDensityOffsetCount{ fragmentDensityOffsetCount_ }
, pFragmentDensityOffsets{ pFragmentDensityOffsets_ }
{
}
VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapOffsetEndInfoEXT( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
RenderPassFragmentDensityMapOffsetEndInfoEXT( VkRenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: RenderPassFragmentDensityMapOffsetEndInfoEXT( *reinterpret_cast<RenderPassFragmentDensityMapOffsetEndInfoEXT const *>( &rhs ) )
{
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
RenderPassFragmentDensityMapOffsetEndInfoEXT(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const & fragmentDensityOffsets_, const void * pNext_ = nullptr )
: pNext( pNext_ )
, fragmentDensityOffsetCount( static_cast<uint32_t>( fragmentDensityOffsets_.size() ) )
, pFragmentDensityOffsets( fragmentDensityOffsets_.data() )
{
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
RenderPassFragmentDensityMapOffsetEndInfoEXT & operator=( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
RenderPassFragmentDensityMapOffsetEndInfoEXT & operator=( VkRenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT &
setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityOffsetCount = fragmentDensityOffsetCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT &
setPFragmentDensityOffsets( const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
{
pFragmentDensityOffsets = pFragmentDensityOffsets_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
RenderPassFragmentDensityMapOffsetEndInfoEXT & setFragmentDensityOffsets(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const & fragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityOffsetCount = static_cast<uint32_t>( fragmentDensityOffsets_.size() );
pFragmentDensityOffsets = fragmentDensityOffsets_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>( this );
}
operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>( this );
}
operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>( this );
}
operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>( 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 &, uint32_t const &, const VULKAN_HPP_NAMESPACE::Offset2D * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderPassFragmentDensityMapOffsetEndInfoEXT const & ) const = default;
#else
bool operator==( RenderPassFragmentDensityMapOffsetEndInfoEXT 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 ) && ( fragmentDensityOffsetCount == rhs.fragmentDensityOffsetCount ) &&
( pFragmentDensityOffsets == rhs.pFragmentDensityOffsets );
# endif
}
bool operator!=( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT;
const void * pNext = {};
uint32_t fragmentDensityOffsetCount = {};
const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets = {};
};
template <>
struct CppType<StructureType, StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT>
{
using Type = RenderPassFragmentDensityMapOffsetEndInfoEXT;
};
using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT;
// wrapper struct for struct VkRenderPassInputAttachmentAspectCreateInfo, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html
struct RenderPassInputAttachmentAspectCreateInfo
@ -129029,6 +129311,101 @@ namespace VULKAN_HPP_NAMESPACE
using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo;
// wrapper struct for struct VkRenderingEndInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingEndInfoEXT.html
struct RenderingEndInfoEXT
{
using NativeType = VkRenderingEndInfoEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingEndInfoEXT;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR RenderingEndInfoEXT( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {}
VULKAN_HPP_CONSTEXPR RenderingEndInfoEXT( RenderingEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
RenderingEndInfoEXT( VkRenderingEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : RenderingEndInfoEXT( *reinterpret_cast<RenderingEndInfoEXT const *>( &rhs ) )
{
}
RenderingEndInfoEXT & operator=( RenderingEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
RenderingEndInfoEXT & operator=( VkRenderingEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 RenderingEndInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkRenderingEndInfoEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkRenderingEndInfoEXT *>( this );
}
operator VkRenderingEndInfoEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkRenderingEndInfoEXT *>( this );
}
operator VkRenderingEndInfoEXT const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkRenderingEndInfoEXT *>( this );
}
operator VkRenderingEndInfoEXT *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkRenderingEndInfoEXT *>( 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 &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( RenderingEndInfoEXT const & ) const = default;
#else
bool operator==( RenderingEndInfoEXT 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 );
# endif
}
bool operator!=( RenderingEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderingEndInfoEXT;
const void * pNext = {};
};
template <>
struct CppType<StructureType, StructureType::eRenderingEndInfoEXT>
{
using Type = RenderingEndInfoEXT;
};
// wrapper struct for struct VkRenderingFragmentDensityMapAttachmentInfoEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html
struct RenderingFragmentDensityMapAttachmentInfoEXT
@ -135448,147 +135825,6 @@ namespace VULKAN_HPP_NAMESPACE
using SubpassEndInfoKHR = SubpassEndInfo;
// wrapper struct for struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassFragmentDensityMapOffsetEndInfoQCOM.html
struct SubpassFragmentDensityMapOffsetEndInfoQCOM
{
using NativeType = VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM( uint32_t fragmentDensityOffsetCount_ = {},
const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, fragmentDensityOffsetCount{ fragmentDensityOffsetCount_ }
, pFragmentDensityOffsets{ pFragmentDensityOffsets_ }
{
}
VULKAN_HPP_CONSTEXPR SubpassFragmentDensityMapOffsetEndInfoQCOM( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
SubpassFragmentDensityMapOffsetEndInfoQCOM( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: SubpassFragmentDensityMapOffsetEndInfoQCOM( *reinterpret_cast<SubpassFragmentDensityMapOffsetEndInfoQCOM const *>( &rhs ) )
{
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
SubpassFragmentDensityMapOffsetEndInfoQCOM(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const & fragmentDensityOffsets_, const void * pNext_ = nullptr )
: pNext( pNext_ )
, fragmentDensityOffsetCount( static_cast<uint32_t>( fragmentDensityOffsets_.size() ) )
, pFragmentDensityOffsets( fragmentDensityOffsets_.data() )
{
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
SubpassFragmentDensityMapOffsetEndInfoQCOM & operator=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
SubpassFragmentDensityMapOffsetEndInfoQCOM & operator=( VkSubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityOffsetCount = fragmentDensityOffsetCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 SubpassFragmentDensityMapOffsetEndInfoQCOM &
setPFragmentDensityOffsets( const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
{
pFragmentDensityOffsets = pFragmentDensityOffsets_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
SubpassFragmentDensityMapOffsetEndInfoQCOM & setFragmentDensityOffsets(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::Offset2D> const & fragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT
{
fragmentDensityOffsetCount = static_cast<uint32_t>( fragmentDensityOffsets_.size() );
pFragmentDensityOffsets = fragmentDensityOffsets_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
}
operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
}
operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
}
operator VkSubpassFragmentDensityMapOffsetEndInfoQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( 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 &, uint32_t const &, const VULKAN_HPP_NAMESPACE::Offset2D * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( SubpassFragmentDensityMapOffsetEndInfoQCOM const & ) const = default;
#else
bool operator==( SubpassFragmentDensityMapOffsetEndInfoQCOM 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 ) && ( fragmentDensityOffsetCount == rhs.fragmentDensityOffsetCount ) &&
( pFragmentDensityOffsets == rhs.pFragmentDensityOffsets );
# endif
}
bool operator!=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM;
const void * pNext = {};
uint32_t fragmentDensityOffsetCount = {};
const VULKAN_HPP_NAMESPACE::Offset2D * pFragmentDensityOffsets = {};
};
template <>
struct CppType<StructureType, StructureType::eSubpassFragmentDensityMapOffsetEndInfoQCOM>
{
using Type = SubpassFragmentDensityMapOffsetEndInfoQCOM;
};
// wrapper struct for struct VkSubpassResolvePerformanceQueryEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassResolvePerformanceQueryEXT.html
struct SubpassResolvePerformanceQueryEXT

807
include/vulkan/vulkan_to_string.hpp
View file

File diff suppressed because it is too large Load diff

19
registry/base_generator.py
View file

@ -541,11 +541,12 @@ class BaseGenerator(OutputGenerator):
negative = elem.get('dir') is not None
protect = elem.get('protect')
(valueInt, valueStr) = self.enumToValue(elem, True, bitwidth)
# Some values have multiple extensions (ex VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
# genGroup() lists them twice
if next((x for x in fields if x.name == fieldName), None) is None:
fields.append(EnumField(fieldName, negative, protect, []))
fields.append(EnumField(fieldName, protect, negative, valueInt, valueStr, []))
self.vk.enums[groupName] = Enum(groupName, [], groupProtect, bitwidth, True, fields, [], [])
@ -561,19 +562,19 @@ class BaseGenerator(OutputGenerator):
self.flagAliasMap[flagName] = elem.get('alias')
continue
flagMultiBit = False
flagZero = False
flagValue = intIfGet(elem, 'bitpos')
if flagValue is None:
flagValue = intIfGet(elem, 'value')
flagMultiBit = flagValue != 0
flagZero = flagValue == 0
protect = elem.get('protect')
(valueInt, valueStr) = self.enumToValue(elem, True, bitwidth)
flagZero = valueInt == 0
flagMultiBit = False
# if flag uses 'value' instead of 'bitpos', will be zero or a mask
if elem.get('bitpos') is None and elem.get('value'):
flagMultiBit = valueInt != 0
# Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
# genGroup() lists them twice
if next((x for x in fields if x.name == flagName), None) is None:
fields.append(Flag(flagName, protect, flagValue, flagMultiBit, flagZero, []))
fields.append(Flag(flagName, protect, valueInt, valueStr, flagMultiBit, flagZero, []))
flagName = groupName.replace('FlagBits', 'Flags')
self.vk.bitmasks[groupName] = Bitmask(groupName, [], flagName, groupProtect, bitwidth, True, fields, [], [])

32
registry/cgenerator.py
View file

@ -242,7 +242,7 @@ class COutputGenerator(OutputGenerator):
raise MissingGeneratorOptionsError()
if self.genOpts.conventions is None:
raise MissingGeneratorOptionsConventionsError()
is_core = self.featureName and self.featureName.startswith(self.conventions.api_prefix + 'VERSION_')
is_core = self.featureName and self.featureName.startswith(f"{self.conventions.api_prefix}VERSION_")
if self.genOpts.conventions.writeFeature(self.featureName, self.featureExtraProtect, self.genOpts.filename):
self.newline()
if self.genOpts.protectFeature:
@ -340,7 +340,7 @@ class COutputGenerator(OutputGenerator):
# OpenXR: this section was not under 'else:' previously, just fell through
if alias:
# If the type is an alias, just emit a typedef declaration
body += 'typedef ' + alias + ' ' + name + ';\n'
body += f"typedef {alias} {name};\n"
else:
# Replace <apientry /> tags with an APIENTRY-style string
# (from self.genOpts). Copy other text through unchanged.
@ -373,13 +373,13 @@ class COutputGenerator(OutputGenerator):
if ',' in protect_str:
protect_list = protect_str.split(',')
protect_defs = ('defined(%s)' % d for d in protect_list)
protect_defs = (f'defined({d})' for d in protect_list)
protect_def_str = ' && '.join(protect_defs)
protect_if_str = '#if %s\n' % protect_def_str
protect_end_str = '#endif // %s\n' % protect_def_str
protect_if_str = f'#if {protect_def_str}\n'
protect_end_str = f'#endif // {protect_def_str}\n'
else:
protect_if_str = '#ifdef %s\n' % protect_str
protect_end_str = '#endif // %s\n' % protect_str
protect_if_str = f'#ifdef {protect_str}\n'
protect_end_str = f'#endif // {protect_str}\n'
return (protect_if_str, protect_end_str)
@ -423,7 +423,7 @@ class COutputGenerator(OutputGenerator):
body = self.deprecationComment(typeElem)
if alias:
body += 'typedef ' + alias + ' ' + typeName + ';\n'
body += f"typedef {alias} {typeName};\n"
else:
(protect_begin, protect_end) = self.genProtectString(typeElem.get('protect'))
if protect_begin:
@ -431,24 +431,24 @@ class COutputGenerator(OutputGenerator):
if self.genOpts.genStructExtendsComment:
structextends = typeElem.get('structextends')
body += '// ' + typeName + ' extends ' + structextends + '\n' if structextends else ''
body += f"// {typeName} extends {structextends}\n" if structextends else ''
body += 'typedef ' + typeElem.get('category')
body += f"typedef {typeElem.get('category')}"
# This is an OpenXR-specific alternative where aliasing refers
# to an inheritance hierarchy of types rather than C-level type
# aliases.
if self.genOpts.genAliasMacro and self.typeMayAlias(typeName):
body += ' ' + self.genOpts.aliasMacro
body += f" {self.genOpts.aliasMacro}"
body += ' ' + typeName + ' {\n'
body += f" {typeName} {{\n"
targetLen = self.getMaxCParamTypeLength(typeinfo)
for member in typeElem.findall('.//member'):
body += self.deprecationComment(member, indent = 4)
body += self.makeCParamDecl(member, targetLen + 4)
body += ';\n'
body += '} ' + typeName + ';\n'
body += f"}} {typeName};\n"
if protect_end:
body += protect_end
@ -474,13 +474,13 @@ class COutputGenerator(OutputGenerator):
if alias:
# If the group name is aliased, just emit a typedef declaration
# for the alias.
body = 'typedef ' + alias + ' ' + groupName + ';\n'
body = f"typedef {alias} {groupName};\n"
self.appendSection(section, body)
else:
if self.genOpts is None:
raise MissingGeneratorOptionsError()
(section, body) = self.buildEnumCDecl(self.genOpts.genEnumBeginEndRange, groupinfo, groupName)
self.appendSection(section, '\n' + body)
self.appendSection(section, f"\n{body}")
def genEnum(self, enuminfo, name, alias):
"""Generate the C declaration for a constant (a single <enum> value).
@ -507,7 +507,7 @@ class COutputGenerator(OutputGenerator):
prefix = ''
decls = self.makeCDecls(cmdinfo.elem)
self.appendSection('command', prefix + decls[0] + '\n')
self.appendSection('command', f"{prefix + decls[0]}\n")
if self.genOpts.genFuncPointers:
self.appendSection('commandPointer', decls[1])

64
registry/generator.py
View file

@ -116,7 +116,7 @@ class MissingGeneratorOptionsError(RuntimeError):
def __init__(self, msg=None):
full_msg = 'Missing generator options object self.genOpts'
if msg:
full_msg += ': ' + msg
full_msg += f": {msg}"
super().__init__(full_msg)
@ -126,7 +126,7 @@ class MissingRegistryError(RuntimeError):
def __init__(self, msg=None):
full_msg = 'Missing Registry object self.registry'
if msg:
full_msg += ': ' + msg
full_msg += f": {msg}"
super().__init__(full_msg)
@ -136,7 +136,7 @@ class MissingGeneratorOptionsConventionsError(RuntimeError):
def __init__(self, msg=None):
full_msg = 'Missing Conventions object self.genOpts.conventions'
if msg:
full_msg += ': ' + msg
full_msg += f": {msg}"
super().__init__(full_msg)
@ -338,7 +338,7 @@ class OutputGenerator:
)
if name in bad and True:
print('breakName {}: {}'.format(name, msg))
print(f'breakName {name}: {msg}')
pdb.set_trace()
def __init__(self, errFile=sys.stderr, warnFile=sys.stderr, diagFile=sys.stdout):
@ -399,7 +399,7 @@ class OutputGenerator:
write('DIAG:', *args, file=self.diagFile)
else:
raise UserWarning(
'*** FATAL ERROR in Generator.logMsg: unknown level:' + level)
f"*** FATAL ERROR in Generator.logMsg: unknown level:{level}")
def enumToValue(self, elem, needsNum, bitwidth = 32,
forceSuffix = False, parent_for_alias_dereference=None):
@ -452,20 +452,20 @@ class OutputGenerator:
# value += enuminfo.type
if forceSuffix:
if bitwidth == 64:
value = value + 'ULL'
value = f"{value}ULL"
else:
value = value + 'U'
value = f"{value}U"
self.logMsg('diag', 'Enum', name, '-> value [', numVal, ',', value, ']')
return [numVal, value]
if 'bitpos' in elem.keys():
value = elem.get('bitpos')
bitpos = int(value, 0)
numVal = 1 << bitpos
value = '0x%08x' % numVal
value = f'0x{numVal:08x}'
if bitwidth == 64 or bitpos >= 32:
value = value + 'ULL'
value = f"{value}ULL"
elif forceSuffix:
value = value + 'U'
value = f"{value}U"
self.logMsg('diag', 'Enum', name, '-> bitpos [', numVal, ',', value, ']')
return [numVal, value]
if 'offset' in elem.keys():
@ -655,12 +655,12 @@ class OutputGenerator:
flagTypeName = groupElem.get('name')
# Prefix
body = "// Flag bits for " + flagTypeName + "\n"
body = f"// Flag bits for {flagTypeName}\n"
if bitwidth == 64:
body += "typedef VkFlags64 %s;\n" % flagTypeName;
body += f"typedef VkFlags64 {flagTypeName};\n";
else:
body += "typedef VkFlags %s;\n" % flagTypeName;
body += f"typedef VkFlags {flagTypeName};\n";
# Maximum allowable value for a flag (unsigned 64-bit integer)
maxValidValue = 2**(64) - 1
@ -697,25 +697,25 @@ class OutputGenerator:
if self.isEnumRequired(elem):
protect = elem.get('protect')
if protect is not None:
body += '#ifdef {}\n'.format(protect)
body += f'#ifdef {protect}\n'
body += self.deprecationComment(elem, indent = 0)
if usedefine:
decl += "#define {} {}\n".format(name, strVal)
decl += f"#define {name} {strVal}\n"
elif self.misracppstyle():
decl += "static constexpr {} {} {{{}}};\n".format(flagTypeName, name, strVal)
decl += f"static constexpr {flagTypeName} {name} {{{strVal}}};\n"
else:
# Some C compilers only allow initializing a 'static const' variable with a literal value.
# So initializing an alias from another 'static const' value would fail to compile.
# Work around this by chasing the aliases to get the actual value.
while numVal is None:
alias = self.registry.tree.find("enums/enum[@name='" + strVal + "']")
alias = self.registry.tree.find(f"enums/enum[@name='{strVal}']")
if alias is not None:
(numVal, strVal) = self.enumToValue(alias, True, bitwidth, True)
else:
self.logMsg('error', 'No such alias {} for enum {}'.format(strVal, name))
decl += "static const {} {} = {};\n".format(flagTypeName, name, strVal)
self.logMsg('error', f'No such alias {strVal} for enum {name}')
decl += f"static const {flagTypeName} {name} = {strVal};\n"
if numVal is not None:
body += decl
@ -743,7 +743,7 @@ class OutputGenerator:
expandSuffix = ''
expandSuffixMatch = re.search(r'[A-Z][A-Z]+$', groupName)
if expandSuffixMatch:
expandSuffix = '_' + expandSuffixMatch.group()
expandSuffix = f"_{expandSuffixMatch.group()}"
# Strip off the suffix from the prefix
expandPrefix = expandName.rsplit(expandSuffix, 1)[0]
@ -792,12 +792,12 @@ class OutputGenerator:
protect = elem.get('protect')
if protect is not None:
decl += '#ifdef {}\n'.format(protect)
decl += f'#ifdef {protect}\n'
decl += self.genRequirements(name, mustBeFound = False, indent = 2)
decl += self.deprecationComment(elem, indent = 2)
decl += ' {} = {},'.format(name, strVal)
decl += f' {name} = {strVal},'
if protect is not None:
decl += '\n#endif'
@ -868,8 +868,8 @@ class OutputGenerator:
if typeStr != "float":
number += 'U'
strVal = "~" if invert else ""
strVal += "static_cast<" + typeStr + ">(" + number + ")"
body = 'static constexpr ' + typeStr.ljust(9) + name.ljust(33) + ' {' + strVal + '};'
strVal += f"static_cast<{typeStr}>({number})"
body = f"static constexpr {typeStr.ljust(9)}{name.ljust(33)} {{{strVal}}};"
elif enuminfo.elem.get('type') and not alias:
# Generate e.g.: #define x (~0ULL)
typeStr = enuminfo.elem.get('type');
@ -884,10 +884,10 @@ class OutputGenerator:
strVal = "~" if invert else ""
strVal += number
if paren:
strVal = "(" + strVal + ")";
body = '#define ' + name.ljust(33) + ' ' + strVal;
strVal = f"({strVal})";
body = f"#define {name.ljust(33)} {strVal}";
else:
body = '#define ' + name.ljust(33) + ' ' + strVal
body = f"#define {name.ljust(33)} {strVal}"
return body
@ -1102,7 +1102,7 @@ class OutputGenerator:
"""Make the function-pointer typedef name for a command."""
if self.genOpts is None:
raise MissingGeneratorOptionsError()
return '(' + self.genOpts.apientryp + 'PFN_' + name + tail + ')'
return f"({self.genOpts.apientryp}PFN_{name}{tail})"
def makeCParamDecl(self, param, aligncol):
"""Return a string which is an indented, formatted
@ -1135,14 +1135,14 @@ class OutputGenerator:
# This works around a problem where very long type names -
# longer than the alignment column - would run into the tail
# text.
paramdecl = paramdecl.ljust(aligncol - 1) + ' '
paramdecl = f"{paramdecl.ljust(aligncol - 1)} "
newLen = len(paramdecl)
self.logMsg('diag', 'Adjust length of parameter decl from', oldLen, 'to', newLen, ':', paramdecl)
if (self.misracppstyle() and prefix.find('const ') != -1):
# Change pointer type order from e.g. "const void *" to "void const *".
# If the string starts with 'const', reorder it to be after the first type.
paramdecl += prefix.replace('const ', '') + text + ' const' + tail
paramdecl += f"{prefix.replace('const ', '') + text} const{tail}"
else:
paramdecl += prefix + text + tail
@ -1169,7 +1169,7 @@ class OutputGenerator:
# Allow for missing <name> tag
newLen = 0
paramdecl = ' ' + noneStr(param.text)
paramdecl = f" {noneStr(param.text)}"
for elem in param:
text = noneStr(elem.text)
tail = noneStr(elem.tail)
@ -1400,7 +1400,7 @@ class OutputGenerator:
# Change pointer type order from e.g. "const void *" to "void const *".
# If the string starts with 'const', reorder it to be after the first type.
if (prefix.find('const ') != -1):
param += prefix.replace('const ', '') + t + ' const '
param += f"{prefix.replace('const ', '') + t} const "
else:
param += prefix + t
# Clear prefix for subsequent iterations

8
registry/parse_dependency.py
View file

@ -111,7 +111,7 @@ def push_first(toks):
exprStack.append(toks[0])
# An identifier (version, feature boolean, or extension name)
dependencyIdent = Word(alphanums + '_' + ':')
dependencyIdent = Word(f"{alphanums}_:")
# Infix expression for depends expressions
dependencyExpr = pp.infixNotation(dependencyIdent,
@ -288,7 +288,7 @@ def markupTraverse(expr, level = 0, root = True):
- root - True only on initial call"""
if level > 0:
prefix = '{nbsp}{nbsp}' * level * 2 + ' '
prefix = f"{'{nbsp}{nbsp}' * level * 2} "
else:
prefix = ''
str = ''
@ -303,9 +303,9 @@ def markupTraverse(expr, level = 0, root = True):
str = str + markupTraverse(elem, level = nextlevel, root = False)
elif elem in ('+', ','):
str = str + f'{prefix}{opMarkupAsciidoc(elem)} +\n'
str = f"{str}{prefix}{opMarkupAsciidoc(elem)} +\n"
else:
str = str + f'{prefix}{leafMarkupAsciidoc(elem)} +\n'
str = f"{str}{prefix}{leafMarkupAsciidoc(elem)} +\n"
return str

14
registry/reg.py
View file

@ -801,7 +801,7 @@ class Registry:
if enum.get('alias'):
format_name = enum.get('alias')
if format_name in format_condition:
format_condition[format_name] += "," + featureInfo.name
format_condition[format_name] += f",{featureInfo.name}"
else:
format_condition[format_name] = featureInfo.name
elif groupName == "VkPipelineStageFlagBits2":
@ -810,7 +810,7 @@ class Registry:
stage_flag = enum.get('alias')
featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name
if stage_flag in sync_pipeline_stage_condition:
sync_pipeline_stage_condition[stage_flag] += "," + featureName
sync_pipeline_stage_condition[stage_flag] += f",{featureName}"
else:
sync_pipeline_stage_condition[stage_flag] = featureName
elif groupName == "VkAccessFlagBits2":
@ -819,7 +819,7 @@ class Registry:
access_flag = enum.get('alias')
featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name
if access_flag in sync_access_condition:
sync_access_condition[access_flag] += "," + featureName
sync_access_condition[access_flag] += f",{featureName}"
else:
sync_access_condition[access_flag] = featureName
@ -991,7 +991,7 @@ class Registry:
# Look up the Info with matching groupName
if groupName in self.groupdict:
gi = self.groupdict[groupName]
gienum = gi.elem.find("enum[@name='" + enumname + "']")
gienum = gi.elem.find(f"enum[@name='{enumname}']")
if gienum is not None:
# Remove copy of this enum from the group
gi.elem.remove(gienum)
@ -1207,7 +1207,7 @@ class Registry:
self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = []
self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename)
else:
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')
for enumElem in require.findall('enum'):
@ -1224,7 +1224,7 @@ class Registry:
self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = []
self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname)
else:
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')
for cmdElem in require.findall('command'):
# Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
@ -1234,7 +1234,7 @@ class Registry:
self.gen.featureDictionary[featurename]['command'][required_key] = []
self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name'))
else:
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')
def requireFeatures(self, interface, featurename, api, profile):
"""Process `<require>` tags for a `<version>` or `<extension>`.

17
registry/spec_tools/conventions.py
View file

@ -52,7 +52,7 @@ class ProseListFormats(Enum):
return cls.OR
if s == 'and':
return cls.AND
raise RuntimeError("Unrecognized string connective: " + s)
raise RuntimeError(f"Unrecognized string connective: {s}")
@property
def connective(self):
@ -96,11 +96,11 @@ class ConventionsBase(abc.ABC):
def formatVersion(self, name, apivariant, major, minor):
"""Mark up an API version name as a link in the spec."""
return '`<<{}>>`'.format(name)
return f'`<<{name}>>`'
def formatExtension(self, name):
"""Mark up an extension name as a link in the spec."""
return '`<<{}>>`'.format(name)
return f'`<<{name}>>`'
def formatSPIRVlink(self, name):
"""Mark up a SPIR-V extension name as an external link in the spec.
@ -224,7 +224,7 @@ class ConventionsBase(abc.ABC):
my_elts = list(elements)
if len(my_elts) > 1:
my_elts[-1] = '{} {}'.format(fmt.connective, my_elts[-1])
my_elts[-1] = f'{fmt.connective} {my_elts[-1]}'
if not comma_for_two_elts and len(my_elts) <= 2:
prose = ' '.join(my_elts)
@ -351,7 +351,7 @@ class ConventionsBase(abc.ABC):
Implemented in terms of api_prefix.
May override."""
return self.api_prefix + 'VERSION_'
return f"{self.api_prefix}VERSION_"
@property
def KHR_prefix(self):
@ -360,7 +360,7 @@ class ConventionsBase(abc.ABC):
Implemented in terms of api_prefix.
May override."""
return self.api_prefix + 'KHR_'
return f"{self.api_prefix}KHR_"
@property
def EXT_prefix(self):
@ -369,7 +369,7 @@ class ConventionsBase(abc.ABC):
Implemented in terms of api_prefix.
May override."""
return self.api_prefix + 'EXT_'
return f"{self.api_prefix}EXT_"
def writeFeature(self, featureName, featureExtraProtect, filename):
"""Return True if OutputGenerator.endFeature should write this feature.
@ -483,8 +483,7 @@ class ConventionsBase(abc.ABC):
file.
- name - extension name"""
return 'include::{{appendices}}/{}[]'.format(
self.extension_file_path(name))
return f'include::{{appendices}}/{self.extension_file_path(name)}[]'
@property
def provisional_extension_warning(self):

512
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

512
registry/vk.xml
View file

@ -179,7 +179,7 @@ branch of the member gitlab server.
#define <name>VKSC_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0</type>
<type api="vulkan" category="define">// Version of this file
#define <name>VK_HEADER_VERSION</name> 310</type>
#define <name>VK_HEADER_VERSION</name> 311</type>
<type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file
#define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 4, VK_HEADER_VERSION)</type>
<type api="vulkansc" category="define">// Version of this file
@ -1983,11 +1983,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkBool32</type> <name>inheritedQueries</name><comment>Queries may be inherited from primary to secondary command buffers</comment></member>
</type>
<type category="struct" name="VkPhysicalDeviceSparseProperties" returnedonly="true">
<member limittype="exact"><type>VkBool32</type> <name>residencyStandard2DBlockShape</name><comment>Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format)</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>residencyStandard2DMultisampleBlockShape</name><comment>Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format)</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>residencyStandard3DBlockShape</name><comment>Sparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format)</comment></member>
<member limittype="not"><type>VkBool32</type> <name>residencyAlignedMipSize</name><comment>Sparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>residencyNonResidentStrict</name><comment>Sparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded</comment></member>
<member limittype="max"><type>VkBool32</type> <name>residencyStandard2DBlockShape</name><comment>Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format)</comment></member>
<member limittype="max"><type>VkBool32</type> <name>residencyStandard2DMultisampleBlockShape</name><comment>Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format)</comment></member>
<member limittype="max"><type>VkBool32</type> <name>residencyStandard3DBlockShape</name><comment>Sparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format)</comment></member>
<member limittype="min"><type>VkBool32</type> <name>residencyAlignedMipSize</name><comment>Sparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail</comment></member>
<member limittype="max"><type>VkBool32</type> <name>residencyNonResidentStrict</name><comment>Sparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded</comment></member>
</type>
<type category="struct" name="VkPhysicalDeviceLimits" returnedonly="true">
<comment>resource maximum sizes</comment>
@ -2090,7 +2090,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>sampledImageStencilSampleCounts</name><comment>supported stencil sample counts for a sampled image</comment></member>
<member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>storageImageSampleCounts</name><comment>supported sample counts for a storage image</comment></member>
<member limittype="max"><type>uint32_t</type> <name>maxSampleMaskWords</name><comment>max number of sample mask words</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>timestampComputeAndGraphics</name><comment>timestamps on graphics and compute queues</comment></member>
<member limittype="max"><type>VkBool32</type> <name>timestampComputeAndGraphics</name><comment>timestamps on graphics and compute queues</comment></member>
<member limittype="min,mul"><type>float</type> <name>timestampPeriod</name><comment>number of nanoseconds it takes for timestamp query value to increment by 1</comment></member>
<member limittype="max"><type>uint32_t</type> <name>maxClipDistances</name><comment>max number of clip distances</comment></member>
<member limittype="max"><type>uint32_t</type> <name>maxCullDistances</name><comment>max number of cull distances</comment></member>
@ -2100,8 +2100,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="range"><type>float</type> <name>lineWidthRange</name>[2]<comment>range (min,max) of supported line widths</comment></member>
<member limittype="min,mul"><type>float</type> <name>pointSizeGranularity</name><comment>granularity of supported point sizes</comment></member>
<member limittype="min,mul"><type>float</type> <name>lineWidthGranularity</name><comment>granularity of supported line widths</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>strictLines</name><comment>line rasterization follows preferred rules</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>standardSampleLocations</name><comment>supports standard sample locations for all supported sample counts</comment></member>
<member limittype="max"><type>VkBool32</type> <name>strictLines</name><comment>line rasterization follows preferred rules</comment></member>
<member limittype="max"><type>VkBool32</type> <name>standardSampleLocations</name><comment>supports standard sample locations for all supported sample counts</comment></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>optimalBufferCopyOffsetAlignment</name><comment>optimal offset of buffer copies</comment></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>optimalBufferCopyRowPitchAlignment</name><comment>optimal pitch of buffer copies</comment></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>nonCoherentAtomSize</name><comment>minimum size and alignment for non-coherent host-mapped device memory access</comment></member>
@ -3580,7 +3580,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>perViewPositionAllComponents</name></member>
<member limittype="max"><type>VkBool32</type> <name>perViewPositionAllComponents</name></member>
</type>
<type category="struct" name="VkInputAttachmentAspectReference">
<member><type>uint32_t</type> <name>subpass</name></member>
@ -3661,7 +3661,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max,pot" noautovalidity="true"><type>uint32_t</type> <name>subgroupSize</name><comment>The size of a subgroup for this queue.</comment></member>
<member limittype="bitmask" noautovalidity="true"><type>VkShaderStageFlags</type> <name>supportedStages</name><comment>Bitfield of what shader stages support subgroup operations</comment></member>
<member limittype="bitmask" noautovalidity="true"><type>VkSubgroupFeatureFlags</type> <name>supportedOperations</name><comment>Bitfield of what subgroup operations are supported.</comment></member>
<member limittype="exact" noautovalidity="true"><type>VkBool32</type> <name>quadOperationsInAllStages</name><comment>Flag to specify whether quad operations are available in all stages.</comment></member>
<member limittype="max" noautovalidity="true"><type>VkBool32</type> <name>quadOperationsInAllStages</name><comment>Flag to specify whether quad operations are available in all stages.</comment></member>
</type>
<type category="struct" name="VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
@ -3837,8 +3837,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceSamplerFilterMinmaxProperties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>filterMinmaxSingleComponentFormats</name></member>
<member limittype="exact"><type>VkBool32</type> <name>filterMinmaxImageComponentMapping</name></member>
<member limittype="max"><type>VkBool32</type> <name>filterMinmaxSingleComponentFormats</name></member>
<member limittype="max"><type>VkBool32</type> <name>filterMinmaxImageComponentMapping</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT" alias="VkPhysicalDeviceSamplerFilterMinmaxProperties"/>
<type category="struct" name="VkSampleLocationEXT">
@ -3882,7 +3882,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>VkExtent2D</type> <name>maxSampleLocationGridSize</name></member>
<member limittype="range"><type>float</type> <name>sampleLocationCoordinateRange</name>[2]</member>
<member limittype="bits"><type>uint32_t</type> <name>sampleLocationSubPixelBits</name></member>
<member limittype="exact"><type>VkBool32</type> <name>variableSampleLocations</name></member>
<member limittype="max"><type>VkBool32</type> <name>variableSampleLocations</name></member>
</type>
<type category="struct" name="VkMultisamplePropertiesEXT" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
@ -3909,11 +3909,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max"><type>uint32_t</type> <name>advancedBlendMaxColorAttachments</name></member>
<member limittype="exact"><type>VkBool32</type> <name>advancedBlendIndependentBlend</name></member>
<member limittype="exact"><type>VkBool32</type> <name>advancedBlendNonPremultipliedSrcColor</name></member>
<member limittype="exact"><type>VkBool32</type> <name>advancedBlendNonPremultipliedDstColor</name></member>
<member limittype="exact"><type>VkBool32</type> <name>advancedBlendCorrelatedOverlap</name></member>
<member limittype="exact"><type>VkBool32</type> <name>advancedBlendAllOperations</name></member>
<member limittype="max"><type>VkBool32</type> <name>advancedBlendIndependentBlend</name></member>
<member limittype="max"><type>VkBool32</type> <name>advancedBlendNonPremultipliedSrcColor</name></member>
<member limittype="max"><type>VkBool32</type> <name>advancedBlendNonPremultipliedDstColor</name></member>
<member limittype="max"><type>VkBool32</type> <name>advancedBlendCorrelatedOverlap</name></member>
<member limittype="max"><type>VkBool32</type> <name>advancedBlendAllOperations</name></member>
</type>
<type category="struct" name="VkPipelineColorBlendAdvancedStateCreateInfoEXT" structextends="VkPipelineColorBlendStateCreateInfo">
<member values="VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
@ -4008,12 +4008,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceMaintenance5Properties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>earlyFragmentMultisampleCoverageAfterSampleCounting</name></member>
<member limittype="exact"><type>VkBool32</type> <name>earlyFragmentSampleMaskTestBeforeSampleCounting</name></member>
<member limittype="exact"><type>VkBool32</type> <name>depthStencilSwizzleOneSupport</name></member>
<member limittype="exact"><type>VkBool32</type> <name>polygonModePointSize</name></member>
<member limittype="exact"><type>VkBool32</type> <name>nonStrictSinglePixelWideLinesUseParallelogram</name></member>
<member limittype="exact"><type>VkBool32</type> <name>nonStrictWideLinesUseParallelogram</name></member>
<member limittype="max"><type>VkBool32</type> <name>earlyFragmentMultisampleCoverageAfterSampleCounting</name></member>
<member limittype="max"><type>VkBool32</type> <name>earlyFragmentSampleMaskTestBeforeSampleCounting</name></member>
<member limittype="max"><type>VkBool32</type> <name>depthStencilSwizzleOneSupport</name></member>
<member limittype="max"><type>VkBool32</type> <name>polygonModePointSize</name></member>
<member limittype="max"><type>VkBool32</type> <name>nonStrictSinglePixelWideLinesUseParallelogram</name></member>
<member limittype="max"><type>VkBool32</type> <name>nonStrictWideLinesUseParallelogram</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceMaintenance5PropertiesKHR" alias="VkPhysicalDeviceMaintenance5Properties"/>
<type category="struct" name="VkPhysicalDeviceMaintenance6Features" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
@ -4027,7 +4027,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>blockTexelViewCompatibleMultipleLayers</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxCombinedImageSamplerDescriptorCount</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateClampCombinerInputs</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateClampCombinerInputs</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceMaintenance6PropertiesKHR" alias="VkPhysicalDeviceMaintenance6Properties"/>
<type category="struct" name="VkPhysicalDeviceMaintenance7FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
@ -4106,21 +4106,21 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkShaderFloatControlsIndependence</type> <name>denormBehaviorIndependence</name></member>
<member limittype="exact"><type>VkShaderFloatControlsIndependence</type> <name>roundingModeIndependence</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat16</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat32</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat64</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormPreserveFloat16</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormPreserveFloat32</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormPreserveFloat64</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat16</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat32</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat64</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat16</name><comment>An implementation can support RTE</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat32</name><comment>An implementation can support RTE</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat64</name><comment>An implementation can support RTE</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat16</name><comment>An implementation can support RTZ</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat32</name><comment>An implementation can support RTZ</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat64</name><comment>An implementation can support RTZ</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat16</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat32</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat64</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormPreserveFloat16</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormPreserveFloat32</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormPreserveFloat64</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat16</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat32</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat64</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat16</name><comment>An implementation can support RTE</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat32</name><comment>An implementation can support RTE</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat64</name><comment>An implementation can support RTE</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat16</name><comment>An implementation can support RTZ</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat32</name><comment>An implementation can support RTZ</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat64</name><comment>An implementation can support RTZ</comment></member>
</type>
<type category="struct" name="VkPhysicalDeviceFloatControlsPropertiesKHR" alias="VkPhysicalDeviceFloatControlsProperties"/>
<type category="struct" name="VkPhysicalDeviceHostQueryResetFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
@ -4280,12 +4280,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="exact"><type>float</type> <name>primitiveOverestimationSize</name><comment>The size in pixels the primitive is enlarged at each edge during conservative rasterization</comment></member>
<member limittype="max"><type>float</type> <name>maxExtraPrimitiveOverestimationSize</name><comment>The maximum additional overestimation the client can specify in the pipeline state</comment></member>
<member limittype="min,mul"><type>float</type> <name>extraPrimitiveOverestimationSizeGranularity</name><comment>The granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>primitiveUnderestimation</name><comment>true if the implementation supports conservative rasterization underestimation mode</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>conservativePointAndLineRasterization</name><comment>true if conservative rasterization also applies to points and lines</comment></member>
<member limittype="max"><type>VkBool32</type> <name>primitiveUnderestimation</name><comment>true if the implementation supports conservative rasterization underestimation mode</comment></member>
<member limittype="max"><type>VkBool32</type> <name>conservativePointAndLineRasterization</name><comment>true if conservative rasterization also applies to points and lines</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>degenerateTrianglesRasterized</name><comment>true if degenerate triangles (those with zero area after snap) are rasterized</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>degenerateLinesRasterized</name><comment>true if degenerate lines (those with zero length after snap) are rasterized</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>fullyCoveredFragmentShaderInputVariable</name><comment>true if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>conservativeRasterizationPostDepthCoverage</name><comment>true if the implementation supports both conservative rasterization and post depth coverage sample coverage mask</comment></member>
<member limittype="max"><type>VkBool32</type> <name>fullyCoveredFragmentShaderInputVariable</name><comment>true if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable</comment></member>
<member limittype="max"><type>VkBool32</type> <name>conservativeRasterizationPostDepthCoverage</name><comment>true if the implementation supports both conservative rasterization and post depth coverage sample coverage mask</comment></member>
</type>
<type category="struct" name="VkCalibratedTimestampInfoKHR">
<member values="VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
@ -4353,13 +4353,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxUpdateAfterBindDescriptorsInAllPools</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderUniformBufferArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderSampledImageArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderStorageBufferArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderStorageImageArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderInputAttachmentArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>robustBufferAccessUpdateAfterBind</name></member>
<member limittype="exact"><type>VkBool32</type> <name>quadDivergentImplicitLod</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderUniformBufferArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderSampledImageArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderStorageBufferArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderStorageImageArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderInputAttachmentArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>robustBufferAccessUpdateAfterBind</name></member>
<member limittype="max"><type>VkBool32</type> <name>quadDivergentImplicitLod</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindSamplers</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindUniformBuffers</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindStorageBuffers</name></member>
@ -4540,7 +4540,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxVertexAttribDivisor</name><comment>max value of vertex attribute divisor</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>supportsNonZeroFirstInstance</name></member>
<member limittype="max"><type>VkBool32</type> <name>supportsNonZeroFirstInstance</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR" alias="VkPhysicalDeviceVertexAttributeDivisorProperties"/>
<type category="struct" name="VkPhysicalDevicePCIBusInfoPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
@ -4679,8 +4679,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="bitmask"><type>VkResolveModeFlags</type> <name>supportedDepthResolveModes</name><comment>supported depth resolve modes</comment></member>
<member limittype="bitmask"><type>VkResolveModeFlags</type> <name>supportedStencilResolveModes</name><comment>supported stencil resolve modes</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>independentResolveNone</name><comment>depth and stencil resolve modes can be set independently if one of them is none</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>independentResolve</name><comment>depth and stencil resolve modes can be set independently</comment></member>
<member limittype="max"><type>VkBool32</type> <name>independentResolveNone</name><comment>depth and stencil resolve modes can be set independently if one of them is none</comment></member>
<member limittype="max"><type>VkBool32</type> <name>independentResolve</name><comment>depth and stencil resolve modes can be set independently</comment></member>
</type>
<type category="struct" name="VkPhysicalDeviceDepthStencilResolvePropertiesKHR" alias="VkPhysicalDeviceDepthStencilResolveProperties"/>
<type category="struct" name="VkSubpassDescriptionDepthStencilResolve" structextends="VkSubpassDescription2">
@ -4716,10 +4716,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>uint32_t</type> <name>maxTransformFeedbackStreamDataSize</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxTransformFeedbackBufferDataSize</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxTransformFeedbackBufferDataStride</name></member>
<member limittype="exact"><type>VkBool32</type> <name>transformFeedbackQueries</name></member>
<member limittype="exact"><type>VkBool32</type> <name>transformFeedbackStreamsLinesTriangles</name></member>
<member limittype="exact"><type>VkBool32</type> <name>transformFeedbackRasterizationStreamSelect</name></member>
<member limittype="exact"><type>VkBool32</type> <name>transformFeedbackDraw</name></member>
<member limittype="max"><type>VkBool32</type> <name>transformFeedbackQueries</name></member>
<member limittype="max"><type>VkBool32</type> <name>transformFeedbackStreamsLinesTriangles</name></member>
<member limittype="max"><type>VkBool32</type> <name>transformFeedbackRasterizationStreamSelect</name></member>
<member limittype="max"><type>VkBool32</type> <name>transformFeedbackDraw</name></member>
</type>
<type category="struct" name="VkPipelineRasterizationStateStreamCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
<member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
@ -5192,17 +5192,18 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>fragmentDensityMapDeferred</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>fragmentDensityMapOffset</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM" alias="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"/>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="min"><type>VkExtent2D</type> <name>minFragmentDensityTexelSize</name></member>
<member limittype="max"><type>VkExtent2D</type> <name>maxFragmentDensityTexelSize</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentDensityInvocations</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentDensityInvocations</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMap2PropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
@ -5212,22 +5213,24 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>uint32_t</type> <name>maxSubsampledArrayLayers</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetSubsampledSamplers</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="min,mul"><type>VkExtent2D</type> <name>fragmentDensityOffsetGranularity</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM" alias="VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"/>
<type category="struct" name="VkRenderPassFragmentDensityMapCreateInfoEXT" structextends="VkRenderPassCreateInfo,VkRenderPassCreateInfo2">
<member values="VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkAttachmentReference</type> <name>fragmentDensityMapAttachment</name></member>
</type>
<type category="struct" name="VkSubpassFragmentDensityMapOffsetEndInfoQCOM" structextends="VkSubpassEndInfo">
<member values="VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<type category="struct" name="VkRenderPassFragmentDensityMapOffsetEndInfoEXT" structextends="VkSubpassEndInfo,VkRenderingEndInfoEXT">
<member values="VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>uint32_t</type> <name>fragmentDensityOffsetCount</name></member>
<member len="fragmentDensityOffsetCount">const <type>VkOffset2D</type>* <name>pFragmentDensityOffsets</name></member>
</type>
<type category="struct" name="VkSubpassFragmentDensityMapOffsetEndInfoQCOM" alias="VkRenderPassFragmentDensityMapOffsetEndInfoEXT"/>
<type category="struct" name="VkPhysicalDeviceScalarBlockLayoutFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
@ -5458,7 +5461,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDevicePerformanceQueryPropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact" noautovalidity="true"><type>VkBool32</type> <name>allowCommandBufferQueryCopies</name><comment>Flag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults</comment></member>
<member limittype="max" noautovalidity="true"><type>VkBool32</type> <name>allowCommandBufferQueryCopies</name><comment>Flag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults</comment></member>
</type>
<type category="struct" name="VkPerformanceCounterKHR" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR"><type>VkStructureType</type> <name>sType</name></member>
@ -5820,7 +5823,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max,pot" noautovalidity="true"><type>uint32_t</type> <name>subgroupSize</name><comment>The size of a subgroup for this queue.</comment></member>
<member limittype="bitmask" noautovalidity="true"><type>VkShaderStageFlags</type> <name>subgroupSupportedStages</name><comment>Bitfield of what shader stages support subgroup operations</comment></member>
<member limittype="bitmask" noautovalidity="true"><type>VkSubgroupFeatureFlags</type> <name>subgroupSupportedOperations</name><comment>Bitfield of what subgroup operations are supported.</comment></member>
<member limittype="exact" noautovalidity="true"><type>VkBool32</type> <name>subgroupQuadOperationsInAllStages</name><comment>Flag to specify whether quad operations are available in all stages.</comment></member>
<member limittype="max" noautovalidity="true"><type>VkBool32</type> <name>subgroupQuadOperationsInAllStages</name><comment>Flag to specify whether quad operations are available in all stages.</comment></member>
<member limittype="exact"><type>VkPointClippingBehavior</type> <name>pointClippingBehavior</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxMultiviewViewCount</name><comment>max number of views in a subpass</comment></member>
<member limittype="max"><type>uint32_t</type> <name>maxMultiviewInstanceIndex</name><comment>max instance index for a draw in a multiview subpass</comment></member>
@ -5888,29 +5891,29 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="noauto"><type>VkConformanceVersion</type> <name>conformanceVersion</name></member>
<member limittype="exact"><type>VkShaderFloatControlsIndependence</type> <name>denormBehaviorIndependence</name></member>
<member limittype="exact"><type>VkShaderFloatControlsIndependence</type> <name>roundingModeIndependence</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat16</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat32</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat64</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormPreserveFloat16</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormPreserveFloat32</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormPreserveFloat64</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat16</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat32</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat64</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat16</name><comment>An implementation can support RTE</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat32</name><comment>An implementation can support RTE</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat64</name><comment>An implementation can support RTE</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat16</name><comment>An implementation can support RTZ</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat32</name><comment>An implementation can support RTZ</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat64</name><comment>An implementation can support RTZ</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat16</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat32</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderSignedZeroInfNanPreserveFloat64</name><comment>An implementation can preserve signed zero, nan, inf</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormPreserveFloat16</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormPreserveFloat32</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormPreserveFloat64</name><comment>An implementation can preserve denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat16</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat32</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderDenormFlushToZeroFloat64</name><comment>An implementation can flush to zero denormals</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat16</name><comment>An implementation can support RTE</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat32</name><comment>An implementation can support RTE</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTEFloat64</name><comment>An implementation can support RTE</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat16</name><comment>An implementation can support RTZ</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat32</name><comment>An implementation can support RTZ</comment></member>
<member limittype="max"><type>VkBool32</type> <name>shaderRoundingModeRTZFloat64</name><comment>An implementation can support RTZ</comment></member>
<member limittype="max"><type>uint32_t</type> <name>maxUpdateAfterBindDescriptorsInAllPools</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderUniformBufferArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderSampledImageArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderStorageBufferArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderStorageImageArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>shaderInputAttachmentArrayNonUniformIndexingNative</name></member>
<member limittype="exact"><type>VkBool32</type> <name>robustBufferAccessUpdateAfterBind</name></member>
<member limittype="exact"><type>VkBool32</type> <name>quadDivergentImplicitLod</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderUniformBufferArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderSampledImageArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderStorageBufferArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderStorageImageArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>shaderInputAttachmentArrayNonUniformIndexingNative</name></member>
<member limittype="max"><type>VkBool32</type> <name>robustBufferAccessUpdateAfterBind</name></member>
<member limittype="max"><type>VkBool32</type> <name>quadDivergentImplicitLod</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindSamplers</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindUniformBuffers</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxPerStageDescriptorUpdateAfterBindStorageBuffers</name></member>
@ -5928,10 +5931,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindInputAttachments</name></member>
<member limittype="bitmask"><type>VkResolveModeFlags</type> <name>supportedDepthResolveModes</name><comment>supported depth resolve modes</comment></member>
<member limittype="bitmask"><type>VkResolveModeFlags</type> <name>supportedStencilResolveModes</name><comment>supported stencil resolve modes</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>independentResolveNone</name><comment>depth and stencil resolve modes can be set independently if one of them is none</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>independentResolve</name><comment>depth and stencil resolve modes can be set independently</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>filterMinmaxSingleComponentFormats</name></member>
<member limittype="exact"><type>VkBool32</type> <name>filterMinmaxImageComponentMapping</name></member>
<member limittype="max"><type>VkBool32</type> <name>independentResolveNone</name><comment>depth and stencil resolve modes can be set independently if one of them is none</comment></member>
<member limittype="max"><type>VkBool32</type> <name>independentResolve</name><comment>depth and stencil resolve modes can be set independently</comment></member>
<member limittype="max"><type>VkBool32</type> <name>filterMinmaxSingleComponentFormats</name></member>
<member limittype="max"><type>VkBool32</type> <name>filterMinmaxImageComponentMapping</name></member>
<member limittype="max"><type>uint64_t</type> <name>maxTimelineSemaphoreValueDifference</name></member>
<member limittype="bitmask" optional="true"><type>VkSampleCountFlags</type> <name>framebufferIntegerColorSampleCounts</name></member>
</type>
@ -5967,36 +5970,36 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetInlineUniformBlocks</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxDescriptorSetUpdateAfterBindInlineUniformBlocks</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxInlineUniformTotalSize</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct8BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct8BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct8BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct16BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct16BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct16BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct32BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct32BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct32BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct64BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct64BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct64BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct8BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct8BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct8BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct16BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct16BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct16BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct32BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct32BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct32BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct64BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct64BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct64BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated</name></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>storageTexelBufferOffsetAlignmentBytes</name></member>
<member limittype="exact"><type>VkBool32</type> <name>storageTexelBufferOffsetSingleTexelAlignment</name></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>uniformTexelBufferOffsetAlignmentBytes</name></member>
@ -6033,19 +6036,19 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="bits"><type>uint32_t</type> <name>lineSubPixelPrecisionBits</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxVertexAttribDivisor</name><comment>max value of vertex attribute divisor</comment></member>
<member limittype="exact"><type>VkBool32</type> <name>supportsNonZeroFirstInstance</name></member>
<member limittype="max"><type>VkBool32</type> <name>supportsNonZeroFirstInstance</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxPushDescriptors</name></member>
<member limittype="exact"><type>VkBool32</type> <name>dynamicRenderingLocalReadDepthStencilAttachments</name></member>
<member limittype="exact"><type>VkBool32</type> <name>dynamicRenderingLocalReadMultisampledAttachments</name></member>
<member limittype="exact"><type>VkBool32</type> <name>earlyFragmentMultisampleCoverageAfterSampleCounting</name></member>
<member limittype="exact"><type>VkBool32</type> <name>earlyFragmentSampleMaskTestBeforeSampleCounting</name></member>
<member limittype="exact"><type>VkBool32</type> <name>depthStencilSwizzleOneSupport</name></member>
<member limittype="exact"><type>VkBool32</type> <name>polygonModePointSize</name></member>
<member limittype="exact"><type>VkBool32</type> <name>nonStrictSinglePixelWideLinesUseParallelogram</name></member>
<member limittype="exact"><type>VkBool32</type> <name>nonStrictWideLinesUseParallelogram</name></member>
<member limittype="max"><type>VkBool32</type> <name>dynamicRenderingLocalReadDepthStencilAttachments</name></member>
<member limittype="max"><type>VkBool32</type> <name>dynamicRenderingLocalReadMultisampledAttachments</name></member>
<member limittype="max"><type>VkBool32</type> <name>earlyFragmentMultisampleCoverageAfterSampleCounting</name></member>
<member limittype="max"><type>VkBool32</type> <name>earlyFragmentSampleMaskTestBeforeSampleCounting</name></member>
<member limittype="max"><type>VkBool32</type> <name>depthStencilSwizzleOneSupport</name></member>
<member limittype="max"><type>VkBool32</type> <name>polygonModePointSize</name></member>
<member limittype="max"><type>VkBool32</type> <name>nonStrictSinglePixelWideLinesUseParallelogram</name></member>
<member limittype="max"><type>VkBool32</type> <name>nonStrictWideLinesUseParallelogram</name></member>
<member><type>VkBool32</type> <name>blockTexelViewCompatibleMultipleLayers</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxCombinedImageSamplerDescriptorCount</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateClampCombinerInputs</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateClampCombinerInputs</name></member>
<member limittype="exact"><type>VkPipelineRobustnessBufferBehavior</type> <name>defaultRobustnessStorageBuffers</name></member>
<member limittype="exact"><type>VkPipelineRobustnessBufferBehavior</type> <name>defaultRobustnessUniformBuffers</name></member>
<member limittype="exact"><type>VkPipelineRobustnessBufferBehavior</type> <name>defaultRobustnessVertexInputs</name></member>
@ -6055,7 +6058,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true" limittype="noauto"><type>uint32_t</type> <name>copyDstLayoutCount</name></member>
<member optional="true" limittype="noauto" len="copyDstLayoutCount"><type>VkImageLayout</type>* <name>pCopyDstLayouts</name></member>
<member optional="true" limittype="noauto"><type>uint8_t</type> <name>optimalTilingLayoutUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
<member limittype="exact"><type>VkBool32</type> <name>identicalMemoryTypeRequirements</name></member>
<member limittype="max"><type>VkBool32</type> <name>identicalMemoryTypeRequirements</name></member>
</type>
<type category="struct" name="VkPipelineCompilerControlCreateInfoAMD" structextends="VkGraphicsPipelineCreateInfo,VkComputePipelineCreateInfo,VkExecutionGraphPipelineCreateInfoAMDX">
<member values="VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"><type>VkStructureType</type> <name>sType</name></member>
@ -6350,7 +6353,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceExtendedDynamicState3PropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>dynamicPrimitiveTopologyUnrestricted</name></member>
<member limittype="max"><type>VkBool32</type> <name>dynamicPrimitiveTopologyUnrestricted</name></member>
</type>
<type category="struct" name="VkColorBlendEquationEXT">
<member><type>VkBlendFactor</type> <name>srcColorBlendFactor</name></member>
@ -6691,20 +6694,20 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="min"><type>VkExtent2D</type> <name>minFragmentShadingRateAttachmentTexelSize</name></member>
<member limittype="max"><type>VkExtent2D</type> <name>maxFragmentShadingRateAttachmentTexelSize</name></member>
<member limittype="max,pot"><type>uint32_t</type> <name>maxFragmentShadingRateAttachmentTexelSizeAspectRatio</name></member>
<member limittype="exact"><type>VkBool32</type> <name>primitiveFragmentShadingRateWithMultipleViewports</name></member>
<member limittype="exact"><type>VkBool32</type> <name>layeredShadingRateAttachments</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateNonTrivialCombinerOps</name></member>
<member limittype="max"><type>VkBool32</type> <name>primitiveFragmentShadingRateWithMultipleViewports</name></member>
<member limittype="max"><type>VkBool32</type> <name>layeredShadingRateAttachments</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateNonTrivialCombinerOps</name></member>
<member limittype="max"><type>VkExtent2D</type> <name>maxFragmentSize</name></member>
<member limittype="max,pot"><type>uint32_t</type> <name>maxFragmentSizeAspectRatio</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxFragmentShadingRateCoverageSamples</name></member>
<member limittype="max"><type>VkSampleCountFlagBits</type> <name>maxFragmentShadingRateRasterizationSamples</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateWithShaderDepthStencilWrites</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateWithSampleMask</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateWithShaderSampleMask</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateWithConservativeRasterization</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateWithFragmentShaderInterlock</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateWithCustomSampleLocations</name></member>
<member limittype="exact"><type>VkBool32</type> <name>fragmentShadingRateStrictMultiplyCombiner</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateWithShaderDepthStencilWrites</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateWithSampleMask</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateWithShaderSampleMask</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateWithConservativeRasterization</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateWithFragmentShaderInterlock</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateWithCustomSampleLocations</name></member>
<member limittype="max"><type>VkBool32</type> <name>fragmentShadingRateStrictMultiplyCombiner</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentShadingRateKHR" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR"><type>VkStructureType</type> <name>sType</name></member>
@ -7116,7 +7119,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true" limittype="noauto"><type>uint32_t</type> <name>copyDstLayoutCount</name></member>
<member optional="true" limittype="noauto" len="copyDstLayoutCount"><type>VkImageLayout</type>* <name>pCopyDstLayouts</name></member>
<member optional="true" limittype="noauto"><type>uint8_t</type> <name>optimalTilingLayoutUUID</name>[<enum>VK_UUID_SIZE</enum>]</member>
<member limittype="exact"><type>VkBool32</type> <name>identicalMemoryTypeRequirements</name></member>
<member limittype="max"><type>VkBool32</type> <name>identicalMemoryTypeRequirements</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceHostImageCopyPropertiesEXT" alias="VkPhysicalDeviceHostImageCopyProperties"/>
<type category="struct" name="VkMemoryToImageCopy">
@ -7198,14 +7201,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceVulkanSC10Properties" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>deviceNoDynamicHostAllocations</name></member>
<member limittype="exact"><type>VkBool32</type> <name>deviceDestroyFreesMemory</name></member>
<member limittype="exact"><type>VkBool32</type> <name>commandPoolMultipleCommandBuffersRecording</name></member>
<member limittype="exact"><type>VkBool32</type> <name>commandPoolResetCommandBuffer</name></member>
<member limittype="exact"><type>VkBool32</type> <name>commandBufferSimultaneousUse</name></member>
<member limittype="exact"><type>VkBool32</type> <name>secondaryCommandBufferNullOrImagelessFramebuffer</name></member>
<member limittype="exact"><type>VkBool32</type> <name>recycleDescriptorSetMemory</name></member>
<member limittype="exact"><type>VkBool32</type> <name>recyclePipelineMemory</name></member>
<member limittype="max"><type>VkBool32</type> <name>deviceNoDynamicHostAllocations</name></member>
<member limittype="max"><type>VkBool32</type> <name>deviceDestroyFreesMemory</name></member>
<member limittype="max"><type>VkBool32</type> <name>commandPoolMultipleCommandBuffersRecording</name></member>
<member limittype="max"><type>VkBool32</type> <name>commandPoolResetCommandBuffer</name></member>
<member limittype="max"><type>VkBool32</type> <name>commandBufferSimultaneousUse</name></member>
<member limittype="max"><type>VkBool32</type> <name>secondaryCommandBufferNullOrImagelessFramebuffer</name></member>
<member limittype="max"><type>VkBool32</type> <name>recycleDescriptorSetMemory</name></member>
<member limittype="max"><type>VkBool32</type> <name>recyclePipelineMemory</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxRenderPassSubpasses</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxRenderPassDependencies</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxSubpassInputAttachments</name></member>
@ -7781,11 +7784,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>uint32_t</type> <name>maxBPictureL0ReferenceCount</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxL1ReferenceCount</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxTemporalLayerCount</name></member>
<member limittype="not"><type>VkBool32</type> <name>expectDyadicTemporalLayerPattern</name></member>
<member limittype="min"><type>VkBool32</type> <name>expectDyadicTemporalLayerPattern</name></member>
<member limittype="min"><type>int32_t</type> <name>minQp</name></member>
<member limittype="max"><type>int32_t</type> <name>maxQp</name></member>
<member limittype="not"><type>VkBool32</type> <name>prefersGopRemainingFrames</name></member>
<member limittype="not"><type>VkBool32</type> <name>requiresGopRemainingFrames</name></member>
<member limittype="min"><type>VkBool32</type> <name>prefersGopRemainingFrames</name></member>
<member limittype="min"><type>VkBool32</type> <name>requiresGopRemainingFrames</name></member>
<member limittype="bitmask" noautovalidity="true"><type>VkVideoEncodeH264StdFlagsKHR</type> <name>stdSyntaxFlags</name></member>
</type>
<type category="struct" name="VkVideoEncodeH264QualityLevelPropertiesKHR" returnedonly="true" structextends="VkVideoEncodeQualityLevelPropertiesKHR">
@ -7914,11 +7917,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>uint32_t</type> <name>maxBPictureL0ReferenceCount</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxL1ReferenceCount</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxSubLayerCount</name></member>
<member limittype="not"><type>VkBool32</type> <name>expectDyadicTemporalSubLayerPattern</name></member>
<member limittype="min"><type>VkBool32</type> <name>expectDyadicTemporalSubLayerPattern</name></member>
<member limittype="min"><type>int32_t</type> <name>minQp</name></member>
<member limittype="max"><type>int32_t</type> <name>maxQp</name></member>
<member limittype="not"><type>VkBool32</type> <name>prefersGopRemainingFrames</name></member>
<member limittype="not"><type>VkBool32</type> <name>requiresGopRemainingFrames</name></member>
<member limittype="min"><type>VkBool32</type> <name>prefersGopRemainingFrames</name></member>
<member limittype="min"><type>VkBool32</type> <name>requiresGopRemainingFrames</name></member>
<member limittype="bitmask" noautovalidity="true"><type>VkVideoEncodeH265StdFlagsKHR</type> <name>stdSyntaxFlags</name></member>
</type>
<type category="struct" name="VkVideoEncodeH265QualityLevelPropertiesKHR" returnedonly="true" structextends="VkVideoEncodeQualityLevelPropertiesKHR">
@ -8062,8 +8065,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>uint32_t</type> <name>maxOperatingPoints</name></member>
<member limittype="min"><type>uint32_t</type> <name>minQIndex</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxQIndex</name></member>
<member limittype="not"><type>VkBool32</type> <name>prefersGopRemainingFrames</name></member>
<member limittype="not"><type>VkBool32</type> <name>requiresGopRemainingFrames</name></member>
<member limittype="min"><type>VkBool32</type> <name>prefersGopRemainingFrames</name></member>
<member limittype="min"><type>VkBool32</type> <name>requiresGopRemainingFrames</name></member>
<member limittype="bitmask" noautovalidity="true"><type>VkVideoEncodeAV1StdFlagsKHR</type> <name>stdSyntaxFlags</name></member>
</type>
<type category="struct" name="VkVideoEncodeAV1QualityLevelPropertiesKHR" returnedonly="true" structextends="VkVideoEncodeQualityLevelPropertiesKHR">
@ -8194,8 +8197,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceProvokingVertexPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>provokingVertexModePerPipeline</name></member>
<member limittype="exact"><type>VkBool32</type> <name>transformFeedbackPreservesTriangleFanProvokingVertex</name></member>
<member limittype="max"><type>VkBool32</type> <name>provokingVertexModePerPipeline</name></member>
<member limittype="max"><type>VkBool32</type> <name>transformFeedbackPreservesTriangleFanProvokingVertex</name></member>
</type>
<type category="struct" name="VkPipelineRasterizationProvokingVertexStateCreateInfoEXT" structextends="VkPipelineRasterizationStateCreateInfo">
<member values="VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
@ -8361,43 +8364,43 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceShaderIntegerDotProductProperties" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct8BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct8BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct8BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct16BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct16BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct16BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct32BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct32BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct32BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct64BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct64BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProduct64BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitUnsignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitSignedAccelerated</name></member>
<member limittype="exact"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct8BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct8BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct8BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct4x8BitPackedMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct16BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct16BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct16BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct32BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct32BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct32BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct64BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct64BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProduct64BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitUnsignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitSignedAccelerated</name></member>
<member limittype="max"><type>VkBool32</type> <name>integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR" alias="VkPhysicalDeviceShaderIntegerDotProductProperties"/>
<type category="struct" name="VkPhysicalDeviceDrmPropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>hasPrimary</name></member>
<member limittype="exact"><type>VkBool32</type> <name>hasRender</name></member>
<member limittype="max"><type>VkBool32</type> <name>hasPrimary</name></member>
<member limittype="max"><type>VkBool32</type> <name>hasRender</name></member>
<member limittype="noauto"><type>int64_t</type> <name>primaryMajor</name></member>
<member limittype="noauto"><type>int64_t</type> <name>primaryMinor</name></member>
<member limittype="noauto"><type>int64_t</type> <name>renderMajor</name></member>
@ -8411,7 +8414,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>triStripVertexOrderIndependentOfProvokingVertex</name></member>
<member limittype="max"><type>VkBool32</type> <name>triStripVertexOrderIndependentOfProvokingVertex</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceRayTracingMotionBlurFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
@ -8663,6 +8666,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true">const <type>VkRenderingAttachmentInfo</type>* <name>pStencilAttachment</name></member>
</type>
<type category="struct" name="VkRenderingInfoKHR" alias="VkRenderingInfo"/>
<type category="struct" name="VkRenderingEndInfoEXT">
<member values="VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
</type>
<type category="struct" name="VkRenderingAttachmentInfo">
<member values="VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
@ -8772,8 +8779,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="exact"><type>VkBool32</type> <name>graphicsPipelineLibraryFastLinking</name></member>
<member limittype="exact"><type>VkBool32</type> <name>graphicsPipelineLibraryIndependentInterpolationDecoration</name></member>
<member limittype="max"><type>VkBool32</type> <name>graphicsPipelineLibraryFastLinking</name></member>
<member limittype="max"><type>VkBool32</type> <name>graphicsPipelineLibraryIndependentInterpolationDecoration</name></member>
</type>
<type category="struct" name="VkGraphicsPipelineLibraryCreateInfoEXT" structextends="VkGraphicsPipelineCreateInfo">
<member values="VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
@ -9828,7 +9835,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkPhysicalDeviceExternalFormatResolvePropertiesANDROID" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="not"><type>VkBool32</type> <name>nullColorAttachmentWithExternalFormatResolve</name></member>
<member limittype="min"><type>VkBool32</type> <name>nullColorAttachmentWithExternalFormatResolve</name></member>
<member limittype="noauto"><type>VkChromaLocation</type> <name>externalFormatResolveChromaOffsetX</name></member>
<member limittype="noauto"><type>VkChromaLocation</type> <name>externalFormatResolveChromaOffsetY</name></member>
</type>
@ -10038,6 +10045,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member noautovalidity="true"><type>void</type>* <name>pPlacedAddress</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceShaderBfloat16FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>shaderBFloat16Type</name></member>
<member><type>VkBool32</type> <name>shaderBFloat16DotProduct</name></member>
<member><type>VkBool32</type> <name>shaderBFloat16CooperativeMatrix</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceRawAccessChainsFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
@ -16263,8 +16277,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
<proto><type>void</type> <name>vkCmdEndRendering</name></proto>
<param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
</command>
<command queues="graphics" renderpass="inside" cmdbufferlevel="primary,secondary" tasks="action,state">
<proto><type>void</type> <name>vkCmdEndRendering2EXT</name></proto>
<param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
<param optional="true">const <type>VkRenderingEndInfoEXT</type>* <name>pRenderingEndInfo</name></param>
</command>
<command name="vkCmdEndRenderingKHR" alias="vkCmdEndRendering"/>
<command>
<proto><type>void</type> <name>vkGetDescriptorSetLayoutHostMappingInfoVALVE</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
@ -19832,7 +19852,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkReleaseDisplayEXT"/>
</require>
</extension>
<extension name="VK_EXT_acquire_xlib_display" number="90" type="instance" depends="VK_EXT_direct_mode_display" author="NV" contact="James Jones @cubanismo" platform="xlib_xrandr" supported="vulkan" nofeatures="true">
<extension name="VK_EXT_acquire_xlib_display" number="90" type="instance" depends="VK_EXT_direct_mode_display" author="NV" contact="James Jones @cubanismo" platform="xlib_xrandr" supported="vulkan" ratified="vulkan" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_acquire_xlib_display&quot;" name="VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME"/>
@ -20529,10 +20549,17 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_shader_stencil_export&quot;" name="VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_AMD_extension_142" number="142" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled">
<extension name="VK_KHR_shader_bfloat16" number="142" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="KHR" contact="Tobias Hector @tobski" supported="vulkan" ratified="vulkan">
<require>
<enum value="0" name="VK_AMD_EXTENSION_142_SPEC_VERSION"/>
<enum value="&quot;VK_AMD_extension_142&quot;" name="VK_AMD_EXTENSION_142_EXTENSION_NAME"/>
<enum value="1" name="VK_KHR_SHADER_BFLOAT16_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_shader_bfloat16&quot;" name="VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR"/>
<type name="VkPhysicalDeviceShaderBfloat16FeaturesKHR"/>
<feature name="shaderBFloat16Type" struct="VkPhysicalDeviceShaderBfloat16FeaturesKHR"/>
<feature name="shaderBFloat16CooperativeMatrix,shaderBFloat16DotProduct" struct="VkPhysicalDeviceShaderBfloat16FeaturesKHR"/>
</require>
<require depends="VK_KHR_cooperative_matrix">
<enum offset="0" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_BFLOAT16_KHR"/>
</require>
</extension>
<extension name="VK_AMD_extension_143" number="143" author="AMD" contact="Mais Alnasser @malnasse" supported="disabled">
@ -21801,7 +21828,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_GOOGLE_extension_217&quot;" name="VK_GOOGLE_EXTENSION_217_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_metal_surface" number="218" type="instance" depends="VK_KHR_surface" platform="metal" supported="vulkan" author="EXT" contact="Dzmitry Malyshau @kvark" nofeatures="true">
<extension name="VK_EXT_metal_surface" number="218" type="instance" depends="VK_KHR_surface" platform="metal" supported="vulkan" ratified="vulkan" author="EXT" contact="Dzmitry Malyshau @kvark" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_METAL_SURFACE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_metal_surface&quot;" name="VK_EXT_METAL_SURFACE_EXTENSION_NAME"/>
@ -22143,7 +22170,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkImageStencilUsageCreateInfoEXT"/>
</require>
</extension>
<extension name="VK_EXT_validation_features" number="248" type="instance" author="LUNARG" contact="Karl Schultz @karl-lunarg" specialuse="debugging" supported="vulkan,vulkansc" deprecatedby="VK_EXT_layer_settings" nofeatures="true">
<extension name="VK_EXT_validation_features" number="248" type="instance" author="LUNARG" contact="Karl Schultz @karl-lunarg" specialuse="debugging" supported="vulkan,vulkansc" ratified="vulkan" deprecatedby="VK_EXT_layer_settings" nofeatures="true">
<require>
<enum value="6" name="VK_EXT_VALIDATION_FEATURES_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_validation_features&quot;" name="VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME"/>
@ -22553,7 +22580,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="shaderImageFloat32AtomicMinMax" struct="VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_surface_maintenance1" number="275" type="instance" depends="VK_KHR_surface+VK_KHR_get_surface_capabilities2" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" nofeatures="true">
<extension name="VK_EXT_surface_maintenance1" number="275" type="instance" depends="VK_KHR_surface+VK_KHR_get_surface_capabilities2" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_surface_maintenance1&quot;" name="VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME"/>
@ -22569,7 +22596,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkSurfacePresentModeCompatibilityEXT"/>
</require>
</extension>
<extension name="VK_EXT_swapchain_maintenance1" number="276" type="device" depends="VK_KHR_swapchain+VK_EXT_surface_maintenance1+(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan">
<extension name="VK_EXT_swapchain_maintenance1" number="276" type="device" depends="VK_KHR_swapchain+VK_EXT_surface_maintenance1+(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_swapchain_maintenance1&quot;" name="VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME"/>
@ -23730,7 +23757,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkGetWinrtDisplayNV"/>
</require>
</extension>
<extension name="VK_EXT_directfb_surface" number="347" type="instance" depends="VK_KHR_surface" platform="directfb" supported="vulkan" author="EXT" contact="Nicolas Caramelli @caramelli" nofeatures="true">
<extension name="VK_EXT_directfb_surface" number="347" type="instance" depends="VK_KHR_surface" platform="directfb" supported="vulkan" ratified="vulkan" author="EXT" contact="Nicolas Caramelli @caramelli" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_directfb_surface&quot;" name="VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME"/>
@ -24658,14 +24685,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="renderPassStriped" struct="VkPhysicalDeviceRenderPassStripedFeaturesARM"/>
</require>
</extension>
<extension name="VK_QCOM_fragment_density_map_offset" number="426" type="device" depends="(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_EXT_fragment_density_map" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan">
<extension name="VK_QCOM_fragment_density_map_offset" number="426" type="device" depends="(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_EXT_fragment_density_map" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan" promotedto="VK_EXT_fragment_density_map_offset">
<require>
<enum value="2" name="VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION"/>
<enum value="3" name="VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_fragment_density_map_offset&quot;" name="VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM"/>
<enum bitpos="15" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM"/>
<enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT"/>
<enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT"/>
<enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM" alias="VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT"/>
<enum extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM" alias="VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT"/>
<type name="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM"/>
<type name="VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM"/>
<type name="VkSubpassFragmentDensityMapOffsetEndInfoQCOM"/>
@ -25116,6 +25143,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="0" name="VK_EXT_EXTENSION_461_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_461&quot;" name="VK_EXT_EXTENSION_461_EXTENSION_NAME"/>
<enum bitpos="39" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_39_BIT_EXT"/>
<enum bitpos="43" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_43_BIT_EXT"/>
<enum bitpos="23" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_23_BIT_EXT"/>
</require>
</extension>
@ -27008,7 +27036,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_602&quot;" name="VK_EXT_EXTENSION_602_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_external_memory_metal" number="603" type="device" depends="VK_KHR_external_memory,VK_VERSION_1_1" author="EXT" contact="Aitor Camacho Larrondo @aitor-lunarg" platform="metal" supported="vulkan" nofeatures="true">
<extension name="VK_EXT_external_memory_metal" number="603" type="device" depends="VK_KHR_external_memory,VK_VERSION_1_1" author="EXT" contact="Aitor Camacho Larrondo @aitor-lunarg" platform="metal" supported="vulkan" ratified="vulkan" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_external_memory_metal&quot;" name="VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME"/>
@ -27080,10 +27108,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_NV_extension_611&quot;" name="VK_NV_EXTENSION_611_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_612" number="612" author="EXT" contact="Hans-Kristian Arntzen @HansKristian-Work" supported="disabled">
<extension name="VK_VALVE_extension_612" number="612" author="EXT" contact="Mike Blumenkrantz @zmike" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_612_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_612&quot;" name="VK_EXT_EXTENSION_612_EXTENSION_NAME"/>
<enum value="0" name="VK_VALVE_EXTENSION_612_SPEC_VERSION"/>
<enum value="&quot;VK_VALVE_extension_612&quot;" name="VK_VALVE_EXTENSION_612_EXTENSION_NAME"/>
<enum bitpos="2" extends="VkRenderPassCreateFlagBits" name="VK_RENDER_PASS_CREATE_RESERVED_2_BIT_VALVE"/>
<enum bitpos="5" extends="VkRenderingFlagBits" name="VK_RENDERING_RESERVED_5_BIT_VALVE"/>
<enum bitpos="40" extends="VkPipelineCreateFlagBits2" name="VK_PIPELINE_CREATE_2_RESERVED_40_BIT_VALVE"/>
</require>
</extension>
<extension name="VK_KHR_extension_613" number="613" author="KHR" contact="Piers Daniell @pdaniell-nv" supported="disabled">
@ -27127,16 +27158,33 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_618&quot;" name="VK_EXT_EXTENSION_618_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_619" number="619" author="EXT" contact="Mike Blumenkrantz @zmike" supported="disabled">
<extension name="VK_EXT_fragment_density_map_offset" number="620" type="device" depends="(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_EXT_fragment_density_map+(VK_KHR_create_renderpass2,VK_VERSION_1_2)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)" author="EXT" contact="Connor Abbott @cwabbott0" supported="vulkan">
<require>
<enum value="0" name="VK_EXT_EXTENSION_619_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_619&quot;" name="VK_EXT_EXTENSION_619_EXTENSION_NAME"/>
<enum value="1" name="VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_fragment_density_map_offset&quot;" name="VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME"/>
<type name="VkRenderingEndInfoEXT"/>
<enum offset="0" extends="VkStructureType" extnumber="426" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT"/>
<enum offset="1" extends="VkStructureType" extnumber="426" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT"/>
<enum offset="2" extends="VkStructureType" extnumber="426" name="VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT"/>
<enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT"/>
<enum bitpos="15" extends="VkImageCreateFlagBits" name="VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT"/>
<type name="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"/>
<type name="VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"/>
<type name="VkRenderPassFragmentDensityMapOffsetEndInfoEXT"/>
<command name="vkCmdEndRendering2EXT"/>
<feature name="fragmentDensityMapOffset" struct="VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_extension_620" number="620" author="EXT" contact="Faith Ekstrand @gfxstrand" supported="disabled">
<extension name="VK_EXT_extension_621" number="621" author="EXT" contact="Mike Blumenkrantz @zmike" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_620_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_620&quot;" name="VK_EXT_EXTENSION_620_EXTENSION_NAME"/>
<enum value="0" name="VK_EXT_EXTENSION_621_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_621&quot;" name="VK_EXT_EXTENSION_621_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_622" number="622" author="EXT" contact="Lina Versace @linyaa" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_622_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_622&quot;" name="VK_EXT_EXTENSION_622_EXTENSION_NAME"/>
</require>
</extension>
</extensions>
@ -28787,6 +28835,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
<spirvextension name="SPV_KHR_quad_control">
<enable extension="VK_KHR_shader_quad_control"/>
</spirvextension>
<spirvextension name="SPV_KHR_bfloat16">
<enable extension="VK_KHR_shader_bfloat16"/>
</spirvextension>
<spirvextension name="SPV_NV_raw_access_chains">
<enable extension="VK_NV_raw_access_chains"/>
</spirvextension>
@ -29326,6 +29377,15 @@ typedef void* <name>MTLSharedEvent_id</name>;
<spirvcapability name="QuadControlKHR">
<enable struct="VkPhysicalDeviceShaderQuadControlFeaturesKHR" feature="shaderQuadControl" requires="VK_KHR_shader_quad_control"/>
</spirvcapability>
<spirvcapability name="BFloat16TypeKHR">
<enable struct="VkPhysicalDeviceShaderBfloat16FeaturesKHR" feature="shaderBFloat16Type" requires="VK_KHR_shader_bfloat16"/>
</spirvcapability>
<spirvcapability name="BFloat16DotProductKHR">
<enable struct="VkPhysicalDeviceShaderBfloat16FeaturesKHR" feature="shaderBFloat16DotProduct" requires="VK_KHR_shader_bfloat16"/>
</spirvcapability>
<spirvcapability name="BFloat16CooperativeMatrixKHR">
<enable struct="VkPhysicalDeviceShaderBfloat16FeaturesKHR" feature="shaderBFloat16CooperativeMatrix" requires="VK_KHR_shader_bfloat16"/>
</spirvcapability>
<spirvcapability name="RawAccessChainsNV">
<enable struct="VkPhysicalDeviceRawAccessChainsFeaturesNV" feature="shaderRawAccessChains" requires="VK_NV_raw_access_chains"/>
</spirvcapability>

3
registry/vkconventions.py
View file

@ -28,6 +28,7 @@ SPECIAL_WORDS = set((
'ASTC', # VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
'D3D12', # VkD3D12FenceSubmitInfoKHR
'Float16', # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
'Bfloat16', # VkPhysicalDeviceShaderBfloat16FeaturesKHR
'ImagePipe', # VkImagePipeSurfaceCreateInfoFUCHSIA
'Int64', # VkPhysicalDeviceShaderAtomicInt64FeaturesKHR
'Int8', # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
@ -38,7 +39,7 @@ SPECIAL_WORDS = set((
))
# A regex to match any of the SPECIAL_WORDS
EXCEPTION_PATTERN = r'(?P<exception>{})'.format(
'|'.join('(%s)' % re.escape(w) for w in SPECIAL_WORDS))
'|'.join(f'({re.escape(w)})' for w in SPECIAL_WORDS))
MAIN_RE = re.compile(
# the negative lookahead is to prevent the all-caps pattern from being too greedy.
r'({}|([0-9]+)|([A-Z][a-z]+)|([A-Z][A-Z]*(?![a-z])))'.format(EXCEPTION_PATTERN))

8
registry/vulkan_object.py
View file

@ -243,9 +243,12 @@ class Struct:
class EnumField:
"""<enum> of type enum"""
name: str # ex) VK_DYNAMIC_STATE_SCISSOR
negative: bool # True if negative values are allowed (ex. VkResult)
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
negative: bool # True if negative values are allowed (ex. VkResult)
value: int
valueStr: str # value as shown in spec (ex. "0", "2", "1000267000", "0x00000004")
# some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
extensions: list[Extension] # None if part of 1.0 core
@ -260,7 +263,7 @@ class Enum:
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
bitWidth: int # 32 or 64
bitWidth: int # 32 or 64 (currently all are 32, but field is to match with Bitmask)
returnedOnly: bool
fields: list[EnumField]
@ -279,6 +282,7 @@ class Flag:
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
value: int
valueStr: str # value as shown in spec (ex. 0x00000000", "0x00000004", "0x0000000F", "0x800000000ULL")
multiBit: bool # if true, more than one bit is set (ex) VK_SHADER_STAGE_ALL_GRAPHICS)
zero: bool # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE)