BeeEngine/vulkan-headers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update for Vulkan-Docs 1.4.314

Browse source
This commit is contained in:
Jon Leech 2025-05-05 03:15:03 -07:00 • committed by Jon Leech
parent e2e53a7246
commit 9c77de5c3d
16 changed files with 584 additions and 251 deletions
Download patch file Download diff file Expand all files Collapse all files

10
include/vulkan/vulkan.cppm
View file

@ -42,6 +42,11 @@ export namespace VULKAN_HPP_NAMESPACE
{
using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase;
using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic;
#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
using VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic;
# endif
#endif
#if !defined( VK_NO_PROTOTYPES )
using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic;
using VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic;
@ -5245,6 +5250,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::componentPlaneIndex;
using VULKAN_HPP_NAMESPACE::componentsAreCompressed;
using VULKAN_HPP_NAMESPACE::compressionScheme;
using VULKAN_HPP_NAMESPACE::getDepthFormats;
using VULKAN_HPP_NAMESPACE::getDepthStencilFormats;
using VULKAN_HPP_NAMESPACE::getStencilFormats;
using VULKAN_HPP_NAMESPACE::hasDepthComponent;
using VULKAN_HPP_NAMESPACE::hasStencilComponent;
using VULKAN_HPP_NAMESPACE::isCompressed;
using VULKAN_HPP_NAMESPACE::packed;
using VULKAN_HPP_NAMESPACE::planeCompatibleFormat;

62
include/vulkan/vulkan.hpp
View file

@ -55,7 +55,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif
#endif
static_assert( VK_HEADER_VERSION == 313, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 314, "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)
@ -9032,6 +9032,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessExtensionName = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION;
//=== VK_KHR_robustness2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2ExtensionName = VK_KHR_ROBUSTNESS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2SpecVersion = VK_KHR_ROBUSTNESS_2_SPEC_VERSION;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringExtensionName = VK_NV_PRESENT_METERING_EXTENSION_NAME;
@ -13890,34 +13894,6 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_EXT_robustness2 ===
template <>
struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRobustness2PropertiesEXT, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
//=== VK_EXT_custom_border_color ===
template <>
struct StructExtends<SamplerCustomBorderColorCreateInfoEXT, SamplerCreateInfo>
@ -18181,6 +18157,34 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_robustness2 ===
template <>
struct StructExtends<PhysicalDeviceRobustness2FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRobustness2FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceRobustness2PropertiesKHR, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
template <>

44
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 313
#define VK_HEADER_VERSION 314
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -839,8 +839,6 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000,
VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001,
VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001,
VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002,
@ -1250,6 +1248,8 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001,
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000,
#endif
@ -1430,6 +1430,8 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES,
VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO,
VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO,
@ -12964,6 +12966,27 @@ typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR {
// VK_KHR_robustness2 is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_robustness2 1
#define VK_KHR_ROBUSTNESS_2_SPEC_VERSION 1
#define VK_KHR_ROBUSTNESS_2_EXTENSION_NAME "VK_KHR_robustness2"
typedef struct VkPhysicalDeviceRobustness2FeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 robustBufferAccess2;
VkBool32 robustImageAccess2;
VkBool32 nullDescriptor;
} VkPhysicalDeviceRobustness2FeaturesKHR;
typedef struct VkPhysicalDeviceRobustness2PropertiesKHR {
VkStructureType sType;
void* pNext;
VkDeviceSize robustStorageBufferAccessSizeAlignment;
VkDeviceSize robustUniformBufferAccessSizeAlignment;
} VkPhysicalDeviceRobustness2PropertiesKHR;
// VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls.
#define VK_EXT_debug_report 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
@ -16945,20 +16968,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(
#define VK_EXT_robustness2 1
#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1
#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2"
typedef struct VkPhysicalDeviceRobustness2FeaturesEXT {
VkStructureType sType;
void* pNext;
VkBool32 robustBufferAccess2;
VkBool32 robustImageAccess2;
VkBool32 nullDescriptor;
} VkPhysicalDeviceRobustness2FeaturesEXT;
typedef VkPhysicalDeviceRobustness2FeaturesKHR VkPhysicalDeviceRobustness2FeaturesEXT;
typedef struct VkPhysicalDeviceRobustness2PropertiesEXT {
VkStructureType sType;
void* pNext;
VkDeviceSize robustStorageBufferAccessSizeAlignment;
VkDeviceSize robustUniformBufferAccessSizeAlignment;
} VkPhysicalDeviceRobustness2PropertiesEXT;
typedef VkPhysicalDeviceRobustness2PropertiesKHR VkPhysicalDeviceRobustness2PropertiesEXT;

6
include/vulkan/vulkan_enums.hpp
View file

@ -1179,8 +1179,6 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceDeviceMemoryReportFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT,
eDeviceDeviceMemoryReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT,
eDeviceMemoryReportCallbackDataEXT = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT,
ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
eSamplerCustomBorderColorCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
ePhysicalDeviceCustomBorderColorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT,
ePhysicalDeviceCustomBorderColorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
@ -1599,6 +1597,10 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceDepthClampZeroOneFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT,
ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT,
ePhysicalDeviceRobustness2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR,
ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
ePhysicalDeviceRobustness2PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR,
ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eSetPresentConfigNV = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV,
ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV,

16
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -477,6 +477,7 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_METAL_EXT*/
"VK_KHR_depth_clamp_zero_one",
"VK_EXT_vertex_attribute_robustness",
"VK_KHR_robustness2",
#if defined( VK_ENABLE_BETA_EXTENSIONS )
"VK_NV_present_metering",
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -2579,6 +2580,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_robustness2",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_fragment_density_map_offset",
{ { "VK_VERSION_1_0",
{ {
@ -2721,6 +2728,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_EXT_shader_demote_to_helper_invocation", "VK_VERSION_1_3" },
{ "VK_KHR_shader_integer_dot_product", "VK_VERSION_1_3" },
{ "VK_EXT_texel_buffer_alignment", "VK_VERSION_1_3" },
{ "VK_EXT_robustness2", "VK_KHR_robustness2" },
{ "VK_KHR_shader_non_semantic_info", "VK_VERSION_1_3" },
{ "VK_EXT_private_data", "VK_VERSION_1_3" },
{ "VK_EXT_pipeline_creation_cache_control", "VK_VERSION_1_3" },
@ -3148,6 +3156,10 @@ namespace VULKAN_HPP_NAMESPACE
{
return "VK_VERSION_1_3";
}
if ( extension == "VK_EXT_robustness2" )
{
return "VK_KHR_robustness2";
}
if ( extension == "VK_KHR_shader_non_semantic_info" )
{
return "VK_VERSION_1_3";
@ -3491,7 +3503,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" )
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" ) || ( extension == "VK_KHR_robustness2" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_present_metering" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -3597,7 +3609,7 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) ||
( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_host_image_copy" ) ||
( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) ||
( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_EXT_robustness2" ) ||
( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) ||
( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) ||
( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) ||

131
include/vulkan/vulkan_format_traits.hpp
View file

@ -12,11 +12,81 @@
namespace VULKAN_HPP_NAMESPACE
{
//=====================
//=== Format Traits ===
//=====================
//=== Function Declarations ===
// The three-dimensional extent of a texel block.
VULKAN_HPP_CONSTEXPR_14 std::array<uint8_t, 3> blockExtent( VULKAN_HPP_NAMESPACE::Format format );
// The texel block size in bytes.
VULKAN_HPP_CONSTEXPR_14 uint8_t blockSize( VULKAN_HPP_NAMESPACE::Format format );
// The class of the format (can't be just named "class"!)
VULKAN_HPP_CONSTEXPR_14 char const * compatibilityClass( VULKAN_HPP_NAMESPACE::Format format );
// The number of bits in this component, if not compressed, otherwise 0.
VULKAN_HPP_CONSTEXPR_14 uint8_t componentBits( VULKAN_HPP_NAMESPACE::Format format, uint8_t component );
// The number of components of this format.
VULKAN_HPP_CONSTEXPR_14 uint8_t componentCount( VULKAN_HPP_NAMESPACE::Format format );
// The name of the component
VULKAN_HPP_CONSTEXPR_14 char const * componentName( VULKAN_HPP_NAMESPACE::Format format, uint8_t component );
// The numeric format of the component
VULKAN_HPP_CONSTEXPR_14 char const * componentNumericFormat( VULKAN_HPP_NAMESPACE::Format format, uint8_t component );
// The plane this component lies in.
VULKAN_HPP_CONSTEXPR_14 uint8_t componentPlaneIndex( VULKAN_HPP_NAMESPACE::Format format, uint8_t component );
// True, if the components of this format are compressed, otherwise false.
VULKAN_HPP_CONSTEXPR_14 bool componentsAreCompressed( VULKAN_HPP_NAMESPACE::Format format );
// A textual description of the compression scheme, or an empty string if it is not compressed
VULKAN_HPP_CONSTEXPR_14 char const * compressionScheme( VULKAN_HPP_NAMESPACE::Format format );
// Get all formats with a depth component
std::vector<VULKAN_HPP_NAMESPACE::Format> const & getDepthFormats();
// Get all formats with a depth and a stencil component
std::vector<VULKAN_HPP_NAMESPACE::Format> const & getDepthStencilFormats();
// Get all formats with a stencil component
std::vector<VULKAN_HPP_NAMESPACE::Format> const & getStencilFormats();
// True, if this format has a depth component
VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( VULKAN_HPP_NAMESPACE::Format format );
// True, if this format has a stencil component
VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( VULKAN_HPP_NAMESPACE::Format format );
// True, if this format is a compressed one.
VULKAN_HPP_CONSTEXPR_14 bool isCompressed( VULKAN_HPP_NAMESPACE::Format format );
// The number of bits into which the format is packed. A single image element in this format can be stored in the same space as a scalar type of this bit
// width.
VULKAN_HPP_CONSTEXPR_14 uint8_t packed( VULKAN_HPP_NAMESPACE::Format format );
// The single-plane format that this plane is compatible with.
VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_NAMESPACE::Format planeCompatibleFormat( VULKAN_HPP_NAMESPACE::Format format, uint8_t plane );
// The number of image planes of this format.
VULKAN_HPP_CONSTEXPR_14 uint8_t planeCount( VULKAN_HPP_NAMESPACE::Format format );
// The relative height of this plane. A value of k means that this plane is 1/k the height of the overall format.
VULKAN_HPP_CONSTEXPR_14 uint8_t planeHeightDivisor( VULKAN_HPP_NAMESPACE::Format format, uint8_t plane );
// The relative width of this plane. A value of k means that this plane is 1/k the width of the overall format.
VULKAN_HPP_CONSTEXPR_14 uint8_t planeWidthDivisor( VULKAN_HPP_NAMESPACE::Format format, uint8_t plane );
// The number of texels in a texel block.
VULKAN_HPP_CONSTEXPR_14 uint8_t texelsPerBlock( VULKAN_HPP_NAMESPACE::Format format );
//=== Function Definitions ===
// The three-dimensional extent of a texel block.
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 std::array<uint8_t, 3> blockExtent( VULKAN_HPP_NAMESPACE::Format format )
{
@ -6730,6 +6800,65 @@ namespace VULKAN_HPP_NAMESPACE
}
}
// Get all formats with a depth component
VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Format> const & getDepthFormats()
{
static std::vector<VULKAN_HPP_NAMESPACE::Format> depthFormats = {
VULKAN_HPP_NAMESPACE::Format::eD16Unorm, VULKAN_HPP_NAMESPACE::Format::eX8D24UnormPack32, VULKAN_HPP_NAMESPACE::Format::eD32Sfloat,
VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint, VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint, VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint
};
return depthFormats;
}
// Get all formats with a depth and a stencil component
VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Format> const & getDepthStencilFormats()
{
static std::vector<VULKAN_HPP_NAMESPACE::Format> depthStencilFormats = { VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint,
VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint,
VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint };
return depthStencilFormats;
}
// Get all formats with a stencil component
VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Format> const & getStencilFormats()
{
static std::vector<VULKAN_HPP_NAMESPACE::Format> stencilFormats = { VULKAN_HPP_NAMESPACE::Format::eS8Uint,
VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint,
VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint,
VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint };
return stencilFormats;
}
// True, if this format has a depth component
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( VULKAN_HPP_NAMESPACE::Format format )
{
switch ( format )
{
case VULKAN_HPP_NAMESPACE::Format::eD16Unorm:
case VULKAN_HPP_NAMESPACE::Format::eX8D24UnormPack32:
case VULKAN_HPP_NAMESPACE::Format::eD32Sfloat:
case VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint:
case VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint:
case VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint: return true;
default: return false;
}
}
// True, if this format has a stencil component
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( VULKAN_HPP_NAMESPACE::Format format )
{
switch ( format )
{
case VULKAN_HPP_NAMESPACE::Format::eS8Uint:
case VULKAN_HPP_NAMESPACE::Format::eD16UnormS8Uint:
case VULKAN_HPP_NAMESPACE::Format::eD24UnormS8Uint:
case VULKAN_HPP_NAMESPACE::Format::eD32SfloatS8Uint: return true;
default: return false;
}
}
// True, if this format is a compressed one.
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool isCompressed( VULKAN_HPP_NAMESPACE::Format format )
{

24
include/vulkan/vulkan_funcs.hpp
View file

@ -25005,35 +25005,15 @@ namespace VULKAN_HPP_NAMESPACE
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT
Device::exportMetalObjectsEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" );
# endif
VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo;
d.vkExportMetalObjectsEXT( m_device, reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
return metalObjectsInfo;
}
// wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
template <typename X, typename Y, typename... Z, typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
Device::exportMetalObjectsEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" );
# endif
VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo = structureChain.template get<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>();
d.vkExportMetalObjectsEXT( m_device, reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
return structureChain;
}
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_METAL_EXT*/

18
include/vulkan/vulkan_handles.hpp
View file

@ -1303,10 +1303,6 @@ namespace VULKAN_HPP_NAMESPACE
struct DeviceDeviceMemoryReportCreateInfoEXT;
struct DeviceMemoryReportCallbackDataEXT;
//=== VK_EXT_robustness2 ===
struct PhysicalDeviceRobustness2FeaturesEXT;
struct PhysicalDeviceRobustness2PropertiesEXT;
//=== VK_EXT_custom_border_color ===
struct SamplerCustomBorderColorCreateInfoEXT;
struct PhysicalDeviceCustomBorderColorPropertiesEXT;
@ -2059,6 +2055,12 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_vertex_attribute_robustness ===
struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
//=== VK_KHR_robustness2 ===
struct PhysicalDeviceRobustness2FeaturesKHR;
using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR;
struct PhysicalDeviceRobustness2PropertiesKHR;
using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
struct SetPresentConfigNV;
@ -16057,12 +16059,8 @@ namespace VULKAN_HPP_NAMESPACE
# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT
exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
// wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
exportMetalObjectsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_METAL_EXT*/

26
include/vulkan/vulkan_hash.hpp
View file

@ -12259,31 +12259,31 @@ namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const & physicalDeviceRobustness2FeaturesEXT ) const VULKAN_HPP_NOEXCEPT
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR const & physicalDeviceRobustness2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2 );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2 );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustBufferAccess2 );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustImageAccess2 );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.nullDescriptor );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const & physicalDeviceRobustness2PropertiesEXT ) const VULKAN_HPP_NOEXCEPT
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR const & physicalDeviceRobustness2PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustStorageBufferAccessSizeAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustUniformBufferAccessSizeAlignment );
return seed;
}
};

33
include/vulkan/vulkan_raii.hpp
View file

@ -2885,12 +2885,18 @@ namespace VULKAN_HPP_NAMESPACE
class CuModuleNVX;
class CuFunctionNVX;
//=== VK_KHR_descriptor_update_template ===
using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
//=== VK_EXT_debug_utils ===
class DebugUtilsMessengerEXT;
//=== VK_KHR_acceleration_structure ===
class AccelerationStructureKHR;
//=== VK_KHR_sampler_ycbcr_conversion ===
using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
//=== VK_EXT_validation_cache ===
class ValidationCacheEXT;
@ -2906,6 +2912,9 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_device_generated_commands ===
class IndirectCommandsLayoutNV;
//=== VK_EXT_private_data ===
using PrivateDataSlotEXT = PrivateDataSlot;
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_cuda_kernel_launch ===
class CudaModuleNV;
@ -5199,11 +5208,7 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_metal_objects ===
// wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT;
// wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
template <typename X, typename Y, typename... Z>
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT;
void exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo ) const VULKAN_HPP_NOEXCEPT;
# endif /*VK_USE_PLATFORM_METAL_EXT*/
//=== VK_EXT_descriptor_buffer ===
@ -24503,27 +24508,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_metal_objects ===
// wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT
VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" );
VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo;
getDispatcher()->vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
return metalObjectsInfo;
}
// wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html
template <typename X, typename Y, typename... Z>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" );
VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo = structureChain.template get<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>();
getDispatcher()->vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
return structureChain;
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/

32
include/vulkan/vulkan_static_assertions.hpp
View file

@ -5183,22 +5183,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DeviceMe
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT>::value,
"DeviceMemoryReportCallbackDataEXT is not nothrow_move_constructible!" );
//=== VK_EXT_robustness2 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT ) == sizeof( VkPhysicalDeviceRobustness2FeaturesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT>::value,
"PhysicalDeviceRobustness2FeaturesEXT is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT ) == sizeof( VkPhysicalDeviceRobustness2PropertiesEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT>::value,
"PhysicalDeviceRobustness2PropertiesEXT is not nothrow_move_constructible!" );
//=== VK_EXT_custom_border_color ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT ) == sizeof( VkSamplerCustomBorderColorCreateInfoEXT ),
@ -8623,6 +8607,22 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>::value,
"PhysicalDeviceVertexAttributeRobustnessFeaturesEXT is not nothrow_move_constructible!" );
//=== VK_KHR_robustness2 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR ) == sizeof( VkPhysicalDeviceRobustness2FeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR>::value,
"PhysicalDeviceRobustness2FeaturesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR ) == sizeof( VkPhysicalDeviceRobustness2PropertiesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR>::value,
"PhysicalDeviceRobustness2PropertiesKHR is not nothrow_move_constructible!" );
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===

116
include/vulkan/vulkan_structs.hpp
View file

@ -100076,17 +100076,17 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
};
// wrapper struct for struct VkPhysicalDeviceRobustness2FeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html
struct PhysicalDeviceRobustness2FeaturesEXT
// wrapper struct for struct VkPhysicalDeviceRobustness2FeaturesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2FeaturesKHR.html
struct PhysicalDeviceRobustness2FeaturesKHR
{
using NativeType = VkPhysicalDeviceRobustness2FeaturesEXT;
using NativeType = VkPhysicalDeviceRobustness2FeaturesKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2FeaturesEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2FeaturesKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ = {},
VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesKHR( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ = {},
VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ = {},
VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
@ -100097,67 +100097,67 @@ namespace VULKAN_HPP_NAMESPACE
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesEXT( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesKHR( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceRobustness2FeaturesEXT( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceRobustness2FeaturesEXT( *reinterpret_cast<PhysicalDeviceRobustness2FeaturesEXT const *>( &rhs ) )
PhysicalDeviceRobustness2FeaturesKHR( VkPhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceRobustness2FeaturesKHR( *reinterpret_cast<PhysicalDeviceRobustness2FeaturesKHR const *>( &rhs ) )
{
}
PhysicalDeviceRobustness2FeaturesEXT & operator=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceRobustness2FeaturesKHR & operator=( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceRobustness2FeaturesEXT & operator=( VkPhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
PhysicalDeviceRobustness2FeaturesKHR & operator=( VkPhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const *>( &rhs );
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesEXT &
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR &
setRobustBufferAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2_ ) VULKAN_HPP_NOEXCEPT
{
robustBufferAccess2 = robustBufferAccess2_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesEXT & setRobustImageAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setRobustImageAccess2( VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2_ ) VULKAN_HPP_NOEXCEPT
{
robustImageAccess2 = robustImageAccess2_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesEXT & setNullDescriptor( VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setNullDescriptor( VULKAN_HPP_NAMESPACE::Bool32 nullDescriptor_ ) VULKAN_HPP_NOEXCEPT
{
nullDescriptor = nullDescriptor_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceRobustness2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceRobustness2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
return *reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR *>( this );
}
operator VkPhysicalDeviceRobustness2FeaturesEXT &() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceRobustness2FeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
return *reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesKHR *>( this );
}
operator VkPhysicalDeviceRobustness2FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceRobustness2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
return reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR *>( this );
}
operator VkPhysicalDeviceRobustness2FeaturesEXT *() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceRobustness2FeaturesKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
@ -100177,9 +100177,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const & ) const = default;
auto operator<=>( PhysicalDeviceRobustness2FeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
@ -100189,14 +100189,14 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2FeaturesEXT;
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2FeaturesKHR;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 robustBufferAccess2 = {};
VULKAN_HPP_NAMESPACE::Bool32 robustImageAccess2 = {};
@ -100204,22 +100204,24 @@ namespace VULKAN_HPP_NAMESPACE
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2FeaturesEXT>
struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2FeaturesKHR>
{
using Type = PhysicalDeviceRobustness2FeaturesEXT;
using Type = PhysicalDeviceRobustness2FeaturesKHR;
};
// wrapper struct for struct VkPhysicalDeviceRobustness2PropertiesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html
struct PhysicalDeviceRobustness2PropertiesEXT
using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR;
// wrapper struct for struct VkPhysicalDeviceRobustness2PropertiesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2PropertiesKHR.html
struct PhysicalDeviceRobustness2PropertiesKHR
{
using NativeType = VkPhysicalDeviceRobustness2PropertiesEXT;
using NativeType = VkPhysicalDeviceRobustness2PropertiesKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2PropertiesEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2PropertiesKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesEXT( VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment_ = {},
VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesKHR( VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize robustUniformBufferAccessSizeAlignment_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
@ -100228,40 +100230,40 @@ namespace VULKAN_HPP_NAMESPACE
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesEXT( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesKHR( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceRobustness2PropertiesEXT( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceRobustness2PropertiesEXT( *reinterpret_cast<PhysicalDeviceRobustness2PropertiesEXT const *>( &rhs ) )
PhysicalDeviceRobustness2PropertiesKHR( VkPhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceRobustness2PropertiesKHR( *reinterpret_cast<PhysicalDeviceRobustness2PropertiesKHR const *>( &rhs ) )
{
}
PhysicalDeviceRobustness2PropertiesEXT & operator=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceRobustness2PropertiesKHR & operator=( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceRobustness2PropertiesEXT & operator=( VkPhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT
PhysicalDeviceRobustness2PropertiesKHR & operator=( VkPhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const *>( &rhs );
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR const *>( &rhs );
return *this;
}
operator VkPhysicalDeviceRobustness2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceRobustness2PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
return *reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesKHR *>( this );
}
operator VkPhysicalDeviceRobustness2PropertiesEXT &() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceRobustness2PropertiesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
return *reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesKHR *>( this );
}
operator VkPhysicalDeviceRobustness2PropertiesEXT const *() const VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceRobustness2PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
return reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesKHR *>( this );
}
operator VkPhysicalDeviceRobustness2PropertiesEXT *() VULKAN_HPP_NOEXCEPT
operator VkPhysicalDeviceRobustness2PropertiesKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
@ -100277,9 +100279,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const & ) const = default;
auto operator<=>( PhysicalDeviceRobustness2PropertiesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
@ -100289,25 +100291,27 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2PropertiesEXT;
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceRobustness2PropertiesKHR;
void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceSize robustStorageBufferAccessSizeAlignment = {};
VULKAN_HPP_NAMESPACE::DeviceSize robustUniformBufferAccessSizeAlignment = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2PropertiesEXT>
struct CppType<StructureType, StructureType::ePhysicalDeviceRobustness2PropertiesKHR>
{
using Type = PhysicalDeviceRobustness2PropertiesEXT;
using Type = PhysicalDeviceRobustness2PropertiesKHR;
};
using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR;
// wrapper struct for struct VkPhysicalDeviceSampleLocationsPropertiesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html
struct PhysicalDeviceSampleLocationsPropertiesEXT

4
include/vulkan/vulkan_to_string.hpp
View file

@ -4717,8 +4717,6 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT: return "PhysicalDeviceDeviceMemoryReportFeaturesEXT";
case StructureType::eDeviceDeviceMemoryReportCreateInfoEXT: return "DeviceDeviceMemoryReportCreateInfoEXT";
case StructureType::eDeviceMemoryReportCallbackDataEXT: return "DeviceMemoryReportCallbackDataEXT";
case StructureType::ePhysicalDeviceRobustness2FeaturesEXT: return "PhysicalDeviceRobustness2FeaturesEXT";
case StructureType::ePhysicalDeviceRobustness2PropertiesEXT: return "PhysicalDeviceRobustness2PropertiesEXT";
case StructureType::eSamplerCustomBorderColorCreateInfoEXT: return "SamplerCustomBorderColorCreateInfoEXT";
case StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT: return "PhysicalDeviceCustomBorderColorPropertiesEXT";
case StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT: return "PhysicalDeviceCustomBorderColorFeaturesEXT";
@ -5130,6 +5128,8 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_METAL_EXT*/
case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR: return "PhysicalDeviceDepthClampZeroOneFeaturesKHR";
case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT: return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
case StructureType::ePhysicalDeviceRobustness2FeaturesKHR: return "PhysicalDeviceRobustness2FeaturesKHR";
case StructureType::ePhysicalDeviceRobustness2PropertiesKHR: return "PhysicalDeviceRobustness2PropertiesKHR";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case StructureType::eSetPresentConfigNV: return "SetPresentConfigNV";
case StructureType::ePhysicalDevicePresentMeteringFeaturesNV: return "PhysicalDevicePresentMeteringFeaturesNV";

52
registry/reg.py
View file

@ -211,6 +211,10 @@ class BaseInfo:
self.elem = elem
"etree Element for this feature"
self.deprecatedbyversion = None
self.deprecatedbyextensions = []
self.deprecatedlink = None
def resetState(self):
"""Reset required/declared to initial values. Used
prior to generating a new API interface."""
@ -349,6 +353,8 @@ class FeatureInfo(BaseInfo):
self.number = 0
self.supported = None
self.deprecates = elem.findall('deprecate')
else:
# Extract vendor portion of <APIprefix>_<vendor>_<name>
self.category = self.name.split('_', 2)[1]
@ -1250,6 +1256,51 @@ class Registry:
if matchAPIProfile(api, profile, feature):
self.markRequired(featurename, feature, True)
def deprecateFeatures(self, interface, featurename, api, profile):
"""Process `<require>` tags for a `<version>` or `<extension>`.
- interface - Element for `<version>` or `<extension>`, containing
`<require>` tags
- featurename - name of the feature
- api - string specifying API name being generated
- profile - string specifying API profile being generated"""
versionmatch = APIConventions().is_api_version_name(featurename)
# <deprecate> marks things that are deprecated by this version/profile
for deprecation in interface.findall('deprecate'):
if matchAPIProfile(api, profile, deprecation):
for typeElem in deprecation.findall('type'):
type = self.lookupElementInfo(typeElem.get('name'), self.typedict)
if type:
if versionmatch is not None:
type.deprecatedbyversion = featurename
else:
type.deprecatedbyextensions += featurename
type.deprecatedlink = deprecation.get('explanationlink')
else:
self.gen.logMsg('error', typeElem.get('name'), ' is tagged for deprecation but not present in registry')
for enumElem in deprecation.findall('enum'):
enum = self.lookupElementInfo(enumElem.get('name'), self.enumdict)
if enum:
if versionmatch is not None:
enum.deprecatedbyversion = featurename
else:
enum.deprecatedbyextensions += featurename
enum.deprecatedlink = deprecation.get('explanationlink')
else:
self.gen.logMsg('error', enumElem.get('name'), ' is tagged for deprecation but not present in registry')
for cmdElem in deprecation.findall('command'):
cmd = self.lookupElementInfo(cmdElem.get('name'), self.cmddict)
if cmd:
if versionmatch is not None:
cmd.deprecatedbyversion = featurename
else:
cmd.deprecatedbyextensions += featurename
cmd.deprecatedlink = deprecation.get('explanationlink')
else:
self.gen.logMsg('error', cmdElem.get('name'), ' is tagged for deprecation but not present in registry')
def removeFeatures(self, interface, featurename, api, profile):
"""Process `<remove>` tags for a `<version>` or `<extension>`.
@ -1750,6 +1801,7 @@ class Registry:
self.gen.logMsg('diag', 'PASS 1: Tagging required and features for', f.name)
self.fillFeatureDictionary(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
self.requireFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
self.deprecateFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
for f in features:

84
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

171
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> 313</type>
#define <name>VK_HEADER_VERSION</name> 314</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
@ -6481,19 +6481,21 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>shaderSubgroupUniformControlFlow</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceRobustness2FeaturesEXT" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<type category="struct" name="VkPhysicalDeviceRobustness2FeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>robustBufferAccess2</name></member>
<member><type>VkBool32</type> <name>robustImageAccess2</name></member>
<member><type>VkBool32</type> <name>nullDescriptor</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceRobustness2PropertiesEXT" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"><type>VkStructureType</type> <name>sType</name></member>
<type category="struct" name="VkPhysicalDeviceRobustness2FeaturesEXT" alias="VkPhysicalDeviceRobustness2FeaturesKHR"/>
<type category="struct" name="VkPhysicalDeviceRobustness2PropertiesKHR" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>robustStorageBufferAccessSizeAlignment</name></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>robustUniformBufferAccessSizeAlignment</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceRobustness2PropertiesEXT" alias="VkPhysicalDeviceRobustness2PropertiesKHR"/>
<type category="struct" name="VkPhysicalDeviceImageRobustnessFeatures" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
@ -14725,16 +14727,16 @@ typedef void* <name>MTLSharedEvent_id</name>;
</command>
<command>
<proto><type>void</type> <name>vkQueueBeginDebugUtilsLabelEXT</name></proto>
<param><type>VkQueue</type> <name>queue</name></param>
<param externsync="true"><type>VkQueue</type> <name>queue</name></param>
<param>const <type>VkDebugUtilsLabelEXT</type>* <name>pLabelInfo</name></param>
</command>
<command>
<proto><type>void</type> <name>vkQueueEndDebugUtilsLabelEXT</name></proto>
<param><type>VkQueue</type> <name>queue</name></param>
<param externsync="true"><type>VkQueue</type> <name>queue</name></param>
</command>
<command>
<proto><type>void</type> <name>vkQueueInsertDebugUtilsLabelEXT</name></proto>
<param><type>VkQueue</type> <name>queue</name></param>
<param externsync="true"><type>VkQueue</type> <name>queue</name></param>
<param>const <type>VkDebugUtilsLabelEXT</type>* <name>pLabelInfo</name></param>
</command>
<command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary" tasks="action,state">
@ -17951,6 +17953,26 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkGetBufferOpaqueCaptureAddress"/>
<command name="vkGetDeviceMemoryOpaqueCaptureAddress"/>
</require>
<deprecate explanationlink="deprecation-renderpass2">
<command name="vkCreateRenderPass"/>
<type name="VkRenderPassCreateInfo"/>
<type name="VkRenderPassCreateFlags"/>
<type name="VkRenderPassCreateFlagBits"/>
<type name="VkAttachmentDescription"/>
<type name="VkAttachmentDescriptionFlags"/>
<type name="VkAttachmentDescriptionFlagBits"/>
<type name="VkSubpassDescription"/>
<type name="VkSubpassDescriptionFlags"/>
<type name="VkSubpassDescriptionFlagBits"/>
<type name="VkAttachmentReference"/>
<type name="VkSubpassDependency"/>
<type name="VkRenderPassInputAttachmentAspectCreateInfo"/>
<type name="VkInputAttachmentAspectReference"/>
<type name="VkRenderPassMultiviewCreateInfo"/>
<command name="vkCmdBeginRenderPass"/>
<command name="vkCmdNextSubpass"/>
<command name="vkCmdEndRenderPass"/>
</deprecate>
</feature>
<feature api="vulkan,vulkansc" name="VK_VERSION_1_3" number="1.3" depends="VK_VERSION_1_2" comment="Vulkan 1.3 core API interface definitions.">
<require>
@ -18503,6 +18525,45 @@ typedef void* <name>MTLSharedEvent_id</name>;
<!-- type name="VkImageSubresource2" comment="Also promoted from KHR in VK_KHR_maintenance5"/ !-->
<!-- command name="vkGetImageSubresourceLayout2" comment="Also promoted from KHR in VK_KHR_maintenance5"/ !-->
</require>
<deprecate explanationlink="deprecation-dynamicrendering">
<type name="VkRenderPass"/>
<type name="VkRenderPassFragmentDensityMapCreateInfoEXT"/>
<command name="vkCreateRenderPass2"/>
<type name="VkRenderPassCreateInfo2"/>
<type name="VkRenderPassCreationControlEXT"/>
<type name="VkRenderPassCreationFeedbackCreateInfoEXT"/>
<type name="VkRenderPassCreationFeedbackInfoEXT"/>
<type name="VkAttachmentDescription2"/>
<type name="VkAttachmentDescriptionStencilLayout"/>
<type name="VkSubpassDescription2"/>
<type name="VkFragmentShadingRateAttachmentInfoKHR"/>
<type name="VkRenderPassSubpassFeedbackCreateInfoEXT"/>
<type name="VkRenderPassSubpassFeedbackInfoEXT"/>
<type name="VkSubpassDescriptionDepthStencilResolve"/>
<type name="VkAttachmentReference2"/>
<type name="VkSubpassDependency2"/>
<command name="vkDestroyRenderPass"/>
<type name="VkFramebuffer"/>
<command name="vkCreateFramebuffer"/>
<type name="VkFramebufferCreateInfo"/>
<type name="VkFramebufferCreateFlagBits"/>
<type name="VkFramebufferCreateFlags"/>
<type name="VkFramebufferAttachmentsCreateInfo"/>
<type name="VkFramebufferAttachmentImageInfo"/>
<command name="vkDestroyFramebuffer"/>
<command name="vkGetRenderAreaGranularity"/>
<type name="VkRenderPassBeginInfo"/>
<type name="VkRenderPassAttachmentBeginInfo"/>
<type name="VkRenderPassSampleLocationsBeginInfoEXT"/>
<type name="VkAttachmentSampleLocationsEXT"/>
<type name="VkSubpassSampleLocationsEXT"/>
<type name="VkSubpassContents"/>
<command name="vkCmdBeginRenderPass2"/>
<command name="vkCmdNextSubpass2"/>
<type name="VkSubpassBeginInfo"/>
<type name="VkSubpassEndInfo"/>
<command name="vkCmdEndRenderPass2"/>
</deprecate>
</feature>
<feature api="vulkansc" name="VKSC_VERSION_1_0" number="1.0" depends="VK_VERSION_1_2" comment="Vulkan SC core API interface definitions">
<require>
@ -20236,6 +20297,26 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkSubpassBeginInfoKHR"/>
<type name="VkSubpassEndInfoKHR"/>
</require>
<deprecate explanationlink="deprecation-renderpass2">
<command name="vkCreateRenderPass"/>
<type name="VkRenderPassCreateInfo"/>
<type name="VkRenderPassCreateFlags"/>
<type name="VkRenderPassCreateFlagBits"/>
<type name="VkAttachmentDescription"/>
<type name="VkAttachmentDescriptionFlags"/>
<type name="VkAttachmentDescriptionFlagBits"/>
<type name="VkSubpassDescription"/>
<type name="VkSubpassDescriptionFlags"/>
<type name="VkSubpassDescriptionFlagBits"/>
<type name="VkAttachmentReference"/>
<type name="VkSubpassDependency"/>
<type name="VkRenderPassInputAttachmentAspectCreateInfo"/>
<type name="VkInputAttachmentAspectReference"/>
<type name="VkRenderPassMultiviewCreateInfo"/>
<command name="vkCmdBeginRenderPass"/>
<command name="vkCmdNextSubpass"/>
<command name="vkCmdEndRenderPass"/>
</deprecate>
</extension>
<extension name="VK_IMG_relaxed_line_rasterization" number="111" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="IMG" contact="James Fitzpatrick @jamesfitzpatrick" supported="vulkan" specialuse="glemulation">
<require>
@ -22156,6 +22237,45 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR" alias="VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO"/>
<feature name="dynamicRenderingLocalRead" struct="VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR"/>
</require>
<deprecate explanationlink="deprecation-dynamicrendering">
<type name="VkRenderPass"/>
<type name="VkRenderPassFragmentDensityMapCreateInfoEXT"/>
<command name="vkCreateRenderPass2"/>
<type name="VkRenderPassCreateInfo2"/>
<type name="VkRenderPassCreationControlEXT"/>
<type name="VkRenderPassCreationFeedbackCreateInfoEXT"/>
<type name="VkRenderPassCreationFeedbackInfoEXT"/>
<type name="VkAttachmentDescription2"/>
<type name="VkAttachmentDescriptionStencilLayout"/>
<type name="VkSubpassDescription2"/>
<type name="VkFragmentShadingRateAttachmentInfoKHR"/>
<type name="VkRenderPassSubpassFeedbackCreateInfoEXT"/>
<type name="VkRenderPassSubpassFeedbackInfoEXT"/>
<type name="VkSubpassDescriptionDepthStencilResolve"/>
<type name="VkAttachmentReference2"/>
<type name="VkSubpassDependency2"/>
<command name="vkDestroyRenderPass"/>
<type name="VkFramebuffer"/>
<command name="vkCreateFramebuffer"/>
<type name="VkFramebufferCreateInfo"/>
<type name="VkFramebufferCreateFlagBits"/>
<type name="VkFramebufferCreateFlags"/>
<type name="VkFramebufferAttachmentsCreateInfo"/>
<type name="VkFramebufferAttachmentImageInfo"/>
<command name="vkDestroyFramebuffer"/>
<command name="vkGetRenderAreaGranularity"/>
<type name="VkRenderPassBeginInfo"/>
<type name="VkRenderPassAttachmentBeginInfo"/>
<type name="VkRenderPassSampleLocationsBeginInfoEXT"/>
<type name="VkAttachmentSampleLocationsEXT"/>
<type name="VkSubpassSampleLocationsEXT"/>
<type name="VkSubpassContents"/>
<command name="vkCmdBeginRenderPass2"/>
<command name="vkCmdNextSubpass2"/>
<type name="VkSubpassBeginInfo"/>
<type name="VkSubpassEndInfo"/>
<command name="vkCmdEndRenderPass2"/>
</deprecate>
</extension>
<extension name="VK_AMD_extension_234" number="234" author="AMD" contact="Martin Dinkov @mdinkov" supported="disabled">
<require>
@ -22893,7 +23013,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="deviceMemoryReport" struct="VkPhysicalDeviceDeviceMemoryReportFeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_acquire_drm_display" number="286" type="instance" depends="VK_EXT_direct_mode_display" author="EXT" contact="Drew DeVault sir@cmpwn.com" supported="vulkan" comment="codespell:ignore devault" nofeatures="true">
<extension name="VK_EXT_acquire_drm_display" number="286" type="instance" depends="VK_EXT_direct_mode_display" author="EXT" contact="Drew DeVault sir@cmpwn.com" supported="vulkan" ratified="vulkan" comment="codespell:ignore devault" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_acquire_drm_display&quot;" name="VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME"/>
@ -22901,12 +23021,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkGetDrmDisplayEXT"/>
</require>
</extension>
<extension name="VK_EXT_robustness2" number="287" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Liam Middlebrook @liam-middlebrook" supported="vulkan,vulkansc" ratified="vulkan,vulkansc">
<extension name="VK_EXT_robustness2" number="287" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Liam Middlebrook @liam-middlebrook" supported="vulkan,vulkansc" promotedto="VK_KHR_robustness2" ratified="vulkan,vulkansc">
<require>
<enum value="1" name="VK_EXT_ROBUSTNESS_2_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_robustness2&quot;" name="VK_EXT_ROBUSTNESS_2_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT"/>
<enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR"/>
<enum extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT" alias="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR"/>
<type name="VkPhysicalDeviceRobustness2FeaturesEXT"/>
<type name="VkPhysicalDeviceRobustness2PropertiesEXT"/>
<feature name="robustBufferAccess2,robustImageAccess2,nullDescriptor" struct="VkPhysicalDeviceRobustness2FeaturesEXT"/>
@ -23669,7 +23789,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="rayTracingMotionBlur" struct="VkPhysicalDeviceRayTracingMotionBlurFeaturesNV"/>
</require>
</extension>
<extension name="VK_EXT_mesh_shader" number="329" type="device" depends="VK_KHR_spirv_1_4,VK_VERSION_1_2" author="EXT" sortorder="1" contact="Christoph Kubisch @pixeljetstream" supported="vulkan">
<extension name="VK_EXT_mesh_shader" number="329" type="device" depends="VK_KHR_spirv_1_4,VK_VERSION_1_2" author="EXT" sortorder="1" contact="Christoph Kubisch @pixeljetstream" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_MESH_SHADER_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_mesh_shader&quot;" name="VK_EXT_MESH_SHADER_EXTENSION_NAME"/>
@ -23982,7 +24102,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkPhysicalDeviceDrmPropertiesEXT"/>
</require>
</extension>
<extension name="VK_EXT_device_address_binding_report" number="355" type="device" depends="(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_EXT_debug_utils" author="EXT" contact="Ralph Potter gitlab:@r_potter" specialuse="debugging,devtools" supported="vulkan">
<extension name="VK_EXT_device_address_binding_report" number="355" type="device" depends="(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_EXT_debug_utils" author="EXT" contact="Ralph Potter gitlab:@r_potter" specialuse="debugging,devtools" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_device_address_binding_report&quot;" name="VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME"/>
@ -24225,7 +24345,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="externalMemoryRDMA" struct="VkPhysicalDeviceExternalMemoryRDMAFeaturesNV"/>
</require>
</extension>
<extension name="VK_EXT_pipeline_properties" number="373" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Mukund Keshava @mkeshavanv" supported="vulkan">
<extension name="VK_EXT_pipeline_properties" number="373" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Mukund Keshava @mkeshavanv" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_pipeline_properties&quot;" name="VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME"/>
@ -24704,7 +24824,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="borderColorSwizzle" struct="VkPhysicalDeviceBorderColorSwizzleFeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_pageable_device_local_memory" number="413" author="EXT" contact="Piers Daniell @pdaniell-nv" type="device" depends="VK_EXT_memory_priority" supported="vulkan">
<extension name="VK_EXT_pageable_device_local_memory" number="413" author="EXT" contact="Piers Daniell @pdaniell-nv" type="device" depends="VK_EXT_memory_priority" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_pageable_device_local_memory&quot;" name="VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME"/>
@ -25398,7 +25518,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="opticalFlow" struct="VkPhysicalDeviceOpticalFlowFeaturesNV"/>
</require>
</extension>
<extension name="VK_EXT_legacy_dithering" number="466" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" specialuse="glemulation">
<extension name="VK_EXT_legacy_dithering" number="466" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan" specialuse="glemulation">
<require>
<enum value="2" name="VK_EXT_LEGACY_DITHERING_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_legacy_dithering&quot;" name="VK_EXT_LEGACY_DITHERING_EXTENSION_NAME"/>
@ -27310,10 +27430,15 @@ typedef void* <name>MTLSharedEvent_id</name>;
<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">
<extension name="VK_KHR_robustness2" number="613" author="KHR" type="device" contact="Piers Daniell @pdaniell-nv" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan" ratified="vulkan">
<require>
<enum value="0" name="VK_KHR_EXTENSION_613_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_extension_613&quot;" name="VK_KHR_EXTENSION_613_EXTENSION_NAME"/>
<enum value="1" name="VK_KHR_ROBUSTNESS_2_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_robustness2&quot;" name="VK_KHR_ROBUSTNESS_2_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" extnumber="287" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR"/>
<enum offset="1" extends="VkStructureType" extnumber="287" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR"/>
<type name="VkPhysicalDeviceRobustness2FeaturesKHR"/>
<type name="VkPhysicalDeviceRobustness2PropertiesKHR"/>
<feature name="robustBufferAccess2,robustImageAccess2,nullDescriptor" struct="VkPhysicalDeviceRobustness2FeaturesKHR"/>
</require>
</extension>
<extension name="VK_NV_present_metering" number="614" type="device" author="NV" contact="Charles Hansen @chansen" supported="vulkan" provisional="true" platform="provisional">
@ -27420,6 +27545,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_NV_extension_627&quot;" name="VK_NV_EXTENSION_627_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_628" number="628" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_628_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_628&quot;" name="VK_EXT_EXTENSION_628_EXTENSION_NAME"/>
</require>
</extension>
</extensions>
<formats>
<format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">