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

Update for Vulkan-Docs 1.4.304

Browse source
This commit is contained in:
Jon Leech 2024-12-19 21:42:01 -08:00 • committed by Jon Leech
parent 6a74a7d65c
commit d4a196d8c8
12 changed files with 1693 additions and 1256 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
include/vulkan/vulkan.cppm
View file

@ -22,6 +22,7 @@ module;
#include <vulkan/vulkan_hash.hpp>
#include <vulkan/vulkan_raii.hpp>
#include <vulkan/vulkan_shared.hpp>
#include <vulkan/vulkan_to_string.hpp>
export module vulkan_hpp;
@ -41,6 +42,7 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic;
#if !defined( VK_NO_PROTOTYPES )
using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic;
using VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic;
#endif /*VK_NO_PROTOTYPES*/
} // namespace detail
@ -2686,6 +2688,30 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::ApiVersion14;
using VULKAN_HPP_NAMESPACE::HeaderVersionComplete;
//====================
//=== FUNCPOINTERs ===
//====================
//=== VK_VERSION_1_0 ===
using VULKAN_HPP_NAMESPACE::PFN_AllocationFunction;
using VULKAN_HPP_NAMESPACE::PFN_FreeFunction;
using VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification;
using VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification;
using VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction;
using VULKAN_HPP_NAMESPACE::PFN_VoidFunction;
//=== VK_EXT_debug_report ===
using VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT;
//=== VK_EXT_debug_utils ===
using VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT;
//=== VK_EXT_device_memory_report ===
using VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT;
//=== VK_LUNARG_direct_driver_loading ===
using VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG;
//===============
//=== STRUCTs ===
//===============

2
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 == 303, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 304, "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)

4
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 303
#define VK_HEADER_VERSION 304
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -5954,7 +5954,7 @@ typedef enum VkDriverId {
VK_DRIVER_ID_MESA_NVK = 24,
VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25,
VK_DRIVER_ID_MESA_HONEYKRISP = 26,
VK_DRIVER_ID_RESERVED_27 = 27,
VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN = 27,
VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,
VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,
VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,

16
include/vulkan/vulkan_enums.hpp
View file

@ -256,8 +256,8 @@ namespace VULKAN_HPP_NAMESPACE
eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT,
eErrorInvalidOpaqueCaptureAddressKHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR,
ePipelineCompileRequired = VK_PIPELINE_COMPILE_REQUIRED,
eErrorPipelineCompileRequiredEXT = VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT,
ePipelineCompileRequiredEXT = VK_PIPELINE_COMPILE_REQUIRED_EXT,
eErrorPipelineCompileRequiredEXT = VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT,
eErrorNotPermitted = VK_ERROR_NOT_PERMITTED,
eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT,
eErrorNotPermittedKHR = VK_ERROR_NOT_PERMITTED_KHR,
@ -413,8 +413,8 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR,
ePhysicalDeviceVariablePointersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
ePhysicalDeviceVariablePointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR,
ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
ePhysicalDeviceVariablePointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR,
ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR,
eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO,
ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
@ -495,8 +495,8 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceShaderAtomicInt64Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR,
ePhysicalDeviceShaderFloat16Int8Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR,
ePhysicalDeviceShaderFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR,
ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR,
ePhysicalDeviceFloatControlsProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
ePhysicalDeviceFloatControlsPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR,
eDescriptorSetLayoutBindingFlagsCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
@ -675,11 +675,11 @@ namespace VULKAN_HPP_NAMESPACE
eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
eDeviceQueueGlobalPriorityCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR,
ePhysicalDeviceGlobalPriorityQueryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES,
ePhysicalDeviceGlobalPriorityQueryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT,
ePhysicalDeviceGlobalPriorityQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR,
ePhysicalDeviceGlobalPriorityQueryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT,
eQueueFamilyGlobalPriorityProperties = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES,
eQueueFamilyGlobalPriorityPropertiesEXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT,
eQueueFamilyGlobalPriorityPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR,
eQueueFamilyGlobalPriorityPropertiesEXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT,
ePhysicalDeviceShaderSubgroupRotateFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES,
ePhysicalDeviceShaderSubgroupRotateFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR,
ePhysicalDeviceShaderFloatControls2Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES,
@ -3532,9 +3532,9 @@ namespace VULKAN_HPP_NAMESPACE
eStore = VK_ATTACHMENT_STORE_OP_STORE,
eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE,
eNone = VK_ATTACHMENT_STORE_OP_NONE,
eNoneEXT = VK_ATTACHMENT_STORE_OP_NONE_EXT,
eNoneKHR = VK_ATTACHMENT_STORE_OP_NONE_KHR,
eNoneQCOM = VK_ATTACHMENT_STORE_OP_NONE_QCOM
eNoneQCOM = VK_ATTACHMENT_STORE_OP_NONE_QCOM,
eNoneEXT = VK_ATTACHMENT_STORE_OP_NONE_EXT
};
enum class DependencyFlagBits : VkDependencyFlags
@ -4151,7 +4151,7 @@ namespace VULKAN_HPP_NAMESPACE
eMesaNvk = VK_DRIVER_ID_MESA_NVK,
eImaginationOpenSourceMESA = VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA,
eMesaHoneykrisp = VK_DRIVER_ID_MESA_HONEYKRISP,
eReserved27 = VK_DRIVER_ID_RESERVED_27
eVulkanScEmulationOnVulkan = VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN
};
using DriverIdKHR = DriverId;

8
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -2400,7 +2400,13 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_cooperative_matrix",
} } } } }
} } } } },
{ "VK_EXT_vertex_attribute_robustness",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } }
};
auto depIt = dependencies.find( extension );
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;

50
include/vulkan/vulkan_handles.hpp
View file

@ -17706,5 +17706,55 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD typename ResultValueType<uint32_t>::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// operators to compare vk::-handles
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>
auto operator<=>( T const & lhs, T const & rhs )
{
return static_cast<typename T::NativeType>( lhs ) <=> static_cast<typename T::NativeType>( rhs );
}
#else
template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>
bool operator==( T const & lhs, T const & rhs )
{
return static_cast<typename T::NativeType>( lhs ) == static_cast<typename T::NativeType>( rhs );
}
template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>
bool operator!=( T const & lhs, T const & rhs )
{
return static_cast<typename T::NativeType>( lhs ) != static_cast<typename T::NativeType>( rhs );
}
template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>
bool operator<( T const & lhs, T const & rhs )
{
return static_cast<typename T::NativeType>( lhs ) < static_cast<typename T::NativeType>( rhs );
}
#endif
template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>
bool operator==( T const & v, std::nullptr_t )
{
return !v;
}
template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>
bool operator==( std::nullptr_t, T const & v )
{
return !v;
}
template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>
bool operator!=( T const & v, std::nullptr_t )
{
return !!v;
}
template <typename T, typename std::enable_if<VULKAN_HPP_NAMESPACE::isVulkanHandleType<T>::value, int>::type = 0>
bool operator!=( std::nullptr_t, T const & v )
{
return !!v;
}
} // namespace VULKAN_HPP_NAMESPACE
#endif

577
include/vulkan/vulkan_structs.hpp
View file

@ -4483,17 +4483,37 @@ namespace VULKAN_HPP_NAMESPACE
using Type = AcquireProfilingLockInfoKHR;
};
typedef void *( VKAPI_PTR * PFN_AllocationFunction )( void * pUserData,
size_t size,
size_t alignment,
VULKAN_HPP_NAMESPACE::SystemAllocationScope allocationScope );
typedef void *( VKAPI_PTR * PFN_ReallocationFunction )(
void * pUserData, void * pOriginal, size_t size, size_t alignment, VULKAN_HPP_NAMESPACE::SystemAllocationScope allocationScope );
typedef void( VKAPI_PTR * PFN_FreeFunction )( void * pUserData, void * pMemory );
typedef void( VKAPI_PTR * PFN_InternalAllocationNotification )( void * pUserData,
size_t size,
VULKAN_HPP_NAMESPACE::InternalAllocationType allocationType,
VULKAN_HPP_NAMESPACE::SystemAllocationScope allocationScope );
typedef void( VKAPI_PTR * PFN_InternalFreeNotification )( void * pUserData,
size_t size,
VULKAN_HPP_NAMESPACE::InternalAllocationType allocationType,
VULKAN_HPP_NAMESPACE::SystemAllocationScope allocationScope );
struct AllocationCallbacks
{
using NativeType = VkAllocationCallbacks;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR AllocationCallbacks( void * pUserData_ = {},
PFN_vkAllocationFunction pfnAllocation_ = {},
PFN_vkReallocationFunction pfnReallocation_ = {},
PFN_vkFreeFunction pfnFree_ = {},
PFN_vkInternalAllocationNotification pfnInternalAllocation_ = {},
PFN_vkInternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR AllocationCallbacks( void * pUserData_ = {},
VULKAN_HPP_NAMESPACE::PFN_AllocationFunction pfnAllocation_ = {},
VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction pfnReallocation_ = {},
VULKAN_HPP_NAMESPACE::PFN_FreeFunction pfnFree_ = {},
VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification pfnInternalAllocation_ = {},
VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT
: pUserData{ pUserData_ }
, pfnAllocation{ pfnAllocation_ }
, pfnReallocation{ pfnReallocation_ }
@ -4509,6 +4529,33 @@ namespace VULKAN_HPP_NAMESPACE
{
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic push
# if defined( __clang__ )
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# endif
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." )
AllocationCallbacks( void * pUserData_,
PFN_vkAllocationFunction pfnAllocation_,
PFN_vkReallocationFunction pfnReallocation_ = {},
PFN_vkFreeFunction pfnFree_ = {},
PFN_vkInternalAllocationNotification pfnInternalAllocation_ = {},
PFN_vkInternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT
: AllocationCallbacks( pUserData_,
reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_AllocationFunction>( pfnAllocation_ ),
reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction>( pfnReallocation_ ),
reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_FreeFunction>( pfnFree_ ),
reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification>( pfnInternalAllocation_ ),
reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification>( pfnInternalFree_ ) )
{
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic pop
# endif
AllocationCallbacks & operator=( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
@ -4525,35 +4572,74 @@ namespace VULKAN_HPP_NAMESPACE
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnAllocation( VULKAN_HPP_NAMESPACE::PFN_AllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT
{
pfnAllocation = pfnAllocation_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnReallocation( VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT
{
pfnReallocation = pfnReallocation_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnFree( PFN_vkFreeFunction pfnFree_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnFree( VULKAN_HPP_NAMESPACE::PFN_FreeFunction pfnFree_ ) VULKAN_HPP_NOEXCEPT
{
pfnFree = pfnFree_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks &
setPfnInternalAllocation( VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT
{
pfnInternalAllocation = pfnInternalAllocation_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalFree( VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT
{
pfnInternalFree = pfnInternalFree_;
return *this;
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic push
# if defined( __clang__ )
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# endif
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )
AllocationCallbacks & setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT
{
return setPfnAllocation( reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_AllocationFunction>( pfnAllocation_ ) );
}
VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )
AllocationCallbacks & setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT
{
return setPfnReallocation( reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction>( pfnReallocation_ ) );
}
VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )
AllocationCallbacks & setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT
{
return setPfnInternalAllocation( reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification>( pfnInternalAllocation_ ) );
}
VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )
AllocationCallbacks & setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT
{
return setPfnInternalFree( reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification>( pfnInternalFree_ ) );
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic pop
# endif
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT
@ -4571,11 +4657,11 @@ namespace VULKAN_HPP_NAMESPACE
auto
# else
std::tuple<void * const &,
PFN_vkAllocationFunction const &,
PFN_vkReallocationFunction const &,
PFN_vkFreeFunction const &,
PFN_vkInternalAllocationNotification const &,
PFN_vkInternalFreeNotification const &>
VULKAN_HPP_NAMESPACE::PFN_AllocationFunction const &,
VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction const &,
VULKAN_HPP_NAMESPACE::PFN_FreeFunction const &,
VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification const &,
VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
@ -4599,12 +4685,12 @@ namespace VULKAN_HPP_NAMESPACE
}
public:
void * pUserData = {};
PFN_vkAllocationFunction pfnAllocation = {};
PFN_vkReallocationFunction pfnReallocation = {};
PFN_vkFreeFunction pfnFree = {};
PFN_vkInternalAllocationNotification pfnInternalAllocation = {};
PFN_vkInternalFreeNotification pfnInternalFree = {};
void * pUserData = {};
VULKAN_HPP_NAMESPACE::PFN_AllocationFunction pfnAllocation = {};
VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction pfnReallocation = {};
VULKAN_HPP_NAMESPACE::PFN_FreeFunction pfnFree = {};
VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification pfnInternalAllocation = {};
VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification pfnInternalFree = {};
};
struct AmigoProfilingSubmitInfoSEC
@ -21679,6 +21765,15 @@ namespace VULKAN_HPP_NAMESPACE
using Type = DebugMarkerObjectTagInfoEXT;
};
typedef VULKAN_HPP_NAMESPACE::Bool32( VKAPI_PTR * PFN_DebugReportCallbackEXT )( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags,
VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
uint64_t object,
size_t location,
int32_t messageCode,
const char * pLayerPrefix,
const char * pMessage,
void * pUserData );
struct DebugReportCallbackCreateInfoEXT
{
using NativeType = VkDebugReportCallbackCreateInfoEXT;
@ -21687,10 +21782,10 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugReportCallbackCreateInfoEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_ = {},
PFN_vkDebugReportCallbackEXT pfnCallback_ = {},
void * pUserData_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_ = {},
VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT pfnCallback_ = {},
void * pUserData_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, flags{ flags_ }
, pfnCallback{ pfnCallback_ }
@ -21705,6 +21800,26 @@ namespace VULKAN_HPP_NAMESPACE
{
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic push
# if defined( __clang__ )
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# endif
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." )
DebugReportCallbackCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags_,
PFN_vkDebugReportCallbackEXT pfnCallback_,
void * pUserData_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: DebugReportCallbackCreateInfoEXT( flags_, reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT>( pfnCallback_ ), pUserData_, pNext_ )
{
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic pop
# endif
DebugReportCallbackCreateInfoEXT & operator=( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
@ -21727,7 +21842,8 @@ namespace VULKAN_HPP_NAMESPACE
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT &
setPfnCallback( VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT
{
pfnCallback = pfnCallback_;
return *this;
@ -21738,6 +21854,23 @@ namespace VULKAN_HPP_NAMESPACE
pUserData = pUserData_;
return *this;
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic push
# if defined( __clang__ )
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# endif
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )
DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT
{
return setPfnCallback( reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT>( pfnCallback_ ) );
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic pop
# endif
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
@ -21757,7 +21890,7 @@ namespace VULKAN_HPP_NAMESPACE
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT const &,
PFN_vkDebugReportCallbackEXT const &,
VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT const &,
void * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
@ -21781,11 +21914,11 @@ namespace VULKAN_HPP_NAMESPACE
}
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags = {};
PFN_vkDebugReportCallbackEXT pfnCallback = {};
void * pUserData = {};
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags = {};
VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT pfnCallback = {};
void * pUserData = {};
};
template <>
@ -22313,6 +22446,12 @@ namespace VULKAN_HPP_NAMESPACE
using Type = DebugUtilsMessengerCallbackDataEXT;
};
typedef VULKAN_HPP_NAMESPACE::Bool32( VKAPI_PTR * PFN_DebugUtilsMessengerCallbackEXT )(
VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes,
const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
void * pUserData );
struct DebugUtilsMessengerCreateInfoEXT
{
using NativeType = VkDebugUtilsMessengerCreateInfoEXT;
@ -22321,12 +22460,12 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_ = {},
VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = {},
VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType_ = {},
PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = {},
void * pUserData_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_ = {},
VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = {},
VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType_ = {},
VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ = {},
void * pUserData_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, flags{ flags_ }
, messageSeverity{ messageSeverity_ }
@ -22343,6 +22482,33 @@ namespace VULKAN_HPP_NAMESPACE
{
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic push
# if defined( __clang__ )
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# endif
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." )
DebugUtilsMessengerCreateInfoEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags_,
VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity_,
VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType_,
PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_,
void * pUserData_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: DebugUtilsMessengerCreateInfoEXT( flags_,
messageSeverity_,
messageType_,
reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT>( pfnUserCallback_ ),
pUserData_,
pNext_ )
{
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic pop
# endif
DebugUtilsMessengerCreateInfoEXT & operator=( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
@ -22379,7 +22545,8 @@ namespace VULKAN_HPP_NAMESPACE
return *this;
}
VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT &
setPfnUserCallback( VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT
{
pfnUserCallback = pfnUserCallback_;
return *this;
@ -22390,6 +22557,23 @@ namespace VULKAN_HPP_NAMESPACE
pUserData = pUserData_;
return *this;
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic push
# if defined( __clang__ )
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# endif
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )
DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT
{
return setPfnUserCallback( reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT>( pfnUserCallback_ ) );
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic pop
# endif
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
@ -22411,7 +22595,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT const &,
VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT const &,
VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT const &,
PFN_vkDebugUtilsMessengerCallbackEXT const &,
VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT const &,
void * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
@ -22436,13 +22620,13 @@ namespace VULKAN_HPP_NAMESPACE
}
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags = {};
VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity = {};
VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType = {};
PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback = {};
void * pUserData = {};
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT flags = {};
VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagsEXT messageSeverity = {};
VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageType = {};
VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback = {};
void * pUserData = {};
};
template <>
@ -27842,6 +28026,120 @@ namespace VULKAN_HPP_NAMESPACE
using Type = DeviceCreateInfo;
};
struct DeviceMemoryReportCallbackDataEXT
{
using NativeType = VkDeviceMemoryReportCallbackDataEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryReportCallbackDataEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT(
VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_ = {},
VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT type_ = VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT::eAllocate,
uint64_t memoryObjectId_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize size_ = {},
VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown,
uint64_t objectHandle_ = {},
uint32_t heapIndex_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, flags{ flags_ }
, type{ type_ }
, memoryObjectId{ memoryObjectId_ }
, size{ size_ }
, objectType{ objectType_ }
, objectHandle{ objectHandle_ }
, heapIndex{ heapIndex_ }
{
}
VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
DeviceMemoryReportCallbackDataEXT( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: DeviceMemoryReportCallbackDataEXT( *reinterpret_cast<DeviceMemoryReportCallbackDataEXT const *>( &rhs ) )
{
}
DeviceMemoryReportCallbackDataEXT & operator=( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
DeviceMemoryReportCallbackDataEXT & operator=( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const *>( &rhs );
return *this;
}
operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceMemoryReportCallbackDataEXT *>( this );
}
operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT *>( 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::DeviceMemoryReportFlagsEXT const &,
VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT const &,
uint64_t const &,
VULKAN_HPP_NAMESPACE::DeviceSize const &,
VULKAN_HPP_NAMESPACE::ObjectType const &,
uint64_t const &,
uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default;
#else
bool operator==( DeviceMemoryReportCallbackDataEXT 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 ) && ( flags == rhs.flags ) && ( type == rhs.type ) && ( memoryObjectId == rhs.memoryObjectId ) &&
( size == rhs.size ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex );
# endif
}
bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceMemoryReportCallbackDataEXT;
void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags = {};
VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT type = VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT::eAllocate;
uint64_t memoryObjectId = {};
VULKAN_HPP_NAMESPACE::DeviceSize size = {};
VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown;
uint64_t objectHandle = {};
uint32_t heapIndex = {};
};
template <>
struct CppType<StructureType, StructureType::eDeviceMemoryReportCallbackDataEXT>
{
using Type = DeviceMemoryReportCallbackDataEXT;
};
typedef void( VKAPI_PTR * PFN_DeviceMemoryReportCallbackEXT )( const VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT * pCallbackData,
void * pUserData );
struct DeviceDeviceMemoryReportCreateInfoEXT
{
using NativeType = VkDeviceDeviceMemoryReportCreateInfoEXT;
@ -27850,10 +28148,10 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR DeviceDeviceMemoryReportCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_ = {},
PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_ = {},
void * pUserData_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR DeviceDeviceMemoryReportCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_ = {},
VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ = {},
void * pUserData_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, flags{ flags_ }
, pfnUserCallback{ pfnUserCallback_ }
@ -27868,6 +28166,29 @@ namespace VULKAN_HPP_NAMESPACE
{
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic push
# if defined( __clang__ )
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# endif
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." )
DeviceDeviceMemoryReportCreateInfoEXT( VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_,
PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_,
void * pUserData_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: DeviceDeviceMemoryReportCreateInfoEXT( flags_,
reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT>( pfnUserCallback_ ),
pUserData_,
pNext_ )
{
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic pop
# endif
DeviceDeviceMemoryReportCreateInfoEXT & operator=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
@ -27891,7 +28212,7 @@ namespace VULKAN_HPP_NAMESPACE
}
VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT &
setPfnUserCallback( PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT
setPfnUserCallback( VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT
{
pfnUserCallback = pfnUserCallback_;
return *this;
@ -27902,6 +28223,23 @@ namespace VULKAN_HPP_NAMESPACE
pUserData = pUserData_;
return *this;
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic push
# if defined( __clang__ )
# pragma clang diagnostic ignored "-Wunknown-warning-option"
# endif
# pragma GCC diagnostic ignored "-Wcast-function-type"
# endif
VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." )
DeviceDeviceMemoryReportCreateInfoEXT & setPfnUserCallback( PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT
{
return setPfnUserCallback( reinterpret_cast<VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT>( pfnUserCallback_ ) );
}
# if defined( __clang__ ) || defined( __GNUC__ )
# pragma GCC diagnostic pop
# endif
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT
@ -27921,7 +28259,7 @@ namespace VULKAN_HPP_NAMESPACE
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT const &,
PFN_vkDeviceMemoryReportCallbackEXT const &,
VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT const &,
void * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
@ -27946,11 +28284,11 @@ namespace VULKAN_HPP_NAMESPACE
}
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags = {};
PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback = {};
void * pUserData = {};
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags = {};
VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT pfnUserCallback = {};
void * pUserData = {};
};
template <>
@ -30634,117 +30972,6 @@ namespace VULKAN_HPP_NAMESPACE
using Type = DeviceMemoryOverallocationCreateInfoAMD;
};
struct DeviceMemoryReportCallbackDataEXT
{
using NativeType = VkDeviceMemoryReportCallbackDataEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryReportCallbackDataEXT;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT(
VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags_ = {},
VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT type_ = VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT::eAllocate,
uint64_t memoryObjectId_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize size_ = {},
VULKAN_HPP_NAMESPACE::ObjectType objectType_ = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown,
uint64_t objectHandle_ = {},
uint32_t heapIndex_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, flags{ flags_ }
, type{ type_ }
, memoryObjectId{ memoryObjectId_ }
, size{ size_ }
, objectType{ objectType_ }
, objectHandle{ objectHandle_ }
, heapIndex{ heapIndex_ }
{
}
VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
DeviceMemoryReportCallbackDataEXT( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: DeviceMemoryReportCallbackDataEXT( *reinterpret_cast<DeviceMemoryReportCallbackDataEXT const *>( &rhs ) )
{
}
DeviceMemoryReportCallbackDataEXT & operator=( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
DeviceMemoryReportCallbackDataEXT & operator=( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const *>( &rhs );
return *this;
}
operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkDeviceMemoryReportCallbackDataEXT *>( this );
}
operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT *>( 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::DeviceMemoryReportFlagsEXT const &,
VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT const &,
uint64_t const &,
VULKAN_HPP_NAMESPACE::DeviceSize const &,
VULKAN_HPP_NAMESPACE::ObjectType const &,
uint64_t const &,
uint32_t const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default;
#else
bool operator==( DeviceMemoryReportCallbackDataEXT 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 ) && ( flags == rhs.flags ) && ( type == rhs.type ) && ( memoryObjectId == rhs.memoryObjectId ) &&
( size == rhs.size ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex );
# endif
}
bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDeviceMemoryReportCallbackDataEXT;
void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT flags = {};
VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT type = VULKAN_HPP_NAMESPACE::DeviceMemoryReportEventTypeEXT::eAllocate;
uint64_t memoryObjectId = {};
VULKAN_HPP_NAMESPACE::DeviceSize size = {};
VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eUnknown;
uint64_t objectHandle = {};
uint32_t heapIndex = {};
};
template <>
struct CppType<StructureType, StructureType::eDeviceMemoryReportCallbackDataEXT>
{
using Type = DeviceMemoryReportCallbackDataEXT;
};
#if defined( VK_ENABLE_BETA_EXTENSIONS )
union DeviceOrHostAddressConstAMDX
{
@ -31301,6 +31528,8 @@ namespace VULKAN_HPP_NAMESPACE
using Type = DeviceQueueShaderCoreControlCreateInfoARM;
};
typedef PFN_vkVoidFunction( VKAPI_PTR * PFN_GetInstanceProcAddrLUNARG )( VULKAN_HPP_NAMESPACE::Instance instance, const char * pName );
struct DirectDriverLoadingInfoLUNARG
{
using NativeType = VkDirectDriverLoadingInfoLUNARG;
@ -31310,7 +31539,7 @@ namespace VULKAN_HPP_NAMESPACE
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR DirectDriverLoadingInfoLUNARG( VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG flags_ = {},
PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ = {},
VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, flags{ flags_ }
@ -31348,7 +31577,7 @@ namespace VULKAN_HPP_NAMESPACE
}
VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG &
setPfnGetInstanceProcAddr( PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ ) VULKAN_HPP_NOEXCEPT
setPfnGetInstanceProcAddr( VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ ) VULKAN_HPP_NOEXCEPT
{
pfnGetInstanceProcAddr = pfnGetInstanceProcAddr_;
return *this;
@ -31372,7 +31601,7 @@ namespace VULKAN_HPP_NAMESPACE
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
void * const &,
VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG const &,
PFN_vkGetInstanceProcAddrLUNARG const &>
VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
@ -31398,7 +31627,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDirectDriverLoadingInfoLUNARG;
void * pNext = {};
VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG flags = {};
PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr = {};
VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr = {};
};
template <>

4
include/vulkan/vulkan_to_string.hpp
View file

@ -8,7 +8,7 @@
#ifndef VULKAN_TO_STRING_HPP
#define VULKAN_TO_STRING_HPP
#include <vulkan/vulkan_enums.hpp>
#include <vulkan/vulkan.hpp>
// ignore warnings on using deprecated enum values in this header
#if defined( __clang__ ) || defined( __GNUC__ )
@ -6748,7 +6748,7 @@ namespace VULKAN_HPP_NAMESPACE
case DriverId::eMesaNvk: return "MesaNvk";
case DriverId::eImaginationOpenSourceMESA: return "ImaginationOpenSourceMESA";
case DriverId::eMesaHoneykrisp: return "MesaHoneykrisp";
case DriverId::eReserved27: return "Reserved27";
case DriverId::eVulkanScEmulationOnVulkan: return "VulkanScEmulationOnVulkan";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}

361
include/vulkan/vulkan_video.hpp
View file

@ -364,19 +364,21 @@ namespace VULKAN_HPP_NAMESPACE
enum class AV1ColorPrimaries
{
eBt709 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709,
eBtUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED,
eBt470M = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M,
eBt470BG = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G,
eBt601 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601,
eSmpte240 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240,
eGenericFilm = STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM,
eBt2020 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020,
eXyz = STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ,
eSmpte431 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431,
eSmpte432 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432,
eEbu3213 = STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213,
eInvalid = STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID
eBt709 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709,
eUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
eBtUnspecified VULKAN_HPP_DEPRECATED_17( "eBtUnspecified is deprecated, eUnspecified should be used instead." ) =
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED,
eBt470M = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M,
eBt470BG = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G,
eBt601 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601,
eSmpte240 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240,
eGenericFilm = STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM,
eBt2020 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020,
eXyz = STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ,
eSmpte431 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431,
eSmpte432 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432,
eEbu3213 = STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213,
eInvalid = STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID
};
enum class AV1TransferCharacteristics
@ -3717,6 +3719,339 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> SavedOrderHints = {};
};
//=== vulkan_video_codec_av1std_encode ===
struct EncodeAV1DecoderModelInfo
{
using NativeType = StdVideoEncodeAV1DecoderModelInfo;
operator StdVideoEncodeAV1DecoderModelInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoEncodeAV1DecoderModelInfo *>( this );
}
operator StdVideoEncodeAV1DecoderModelInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoEncodeAV1DecoderModelInfo *>( this );
}
bool operator==( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( buffer_delay_length_minus_1 == rhs.buffer_delay_length_minus_1 ) &&
( buffer_removal_time_length_minus_1 == rhs.buffer_removal_time_length_minus_1 ) &&
( frame_presentation_time_length_minus_1 == rhs.frame_presentation_time_length_minus_1 ) && ( reserved1 == rhs.reserved1 ) &&
( num_units_in_decoding_tick == rhs.num_units_in_decoding_tick );
}
bool operator!=( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
uint8_t buffer_delay_length_minus_1 = {};
uint8_t buffer_removal_time_length_minus_1 = {};
uint8_t frame_presentation_time_length_minus_1 = {};
uint8_t reserved1 = {};
uint32_t num_units_in_decoding_tick = {};
};
struct EncodeAV1ExtensionHeader
{
using NativeType = StdVideoEncodeAV1ExtensionHeader;
operator StdVideoEncodeAV1ExtensionHeader const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoEncodeAV1ExtensionHeader *>( this );
}
operator StdVideoEncodeAV1ExtensionHeader &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoEncodeAV1ExtensionHeader *>( this );
}
bool operator==( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( temporal_id == rhs.temporal_id ) && ( spatial_id == rhs.spatial_id );
}
bool operator!=( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
uint8_t temporal_id = {};
uint8_t spatial_id = {};
};
struct EncodeAV1OperatingPointInfoFlags
{
using NativeType = StdVideoEncodeAV1OperatingPointInfoFlags;
operator StdVideoEncodeAV1OperatingPointInfoFlags const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
}
operator StdVideoEncodeAV1OperatingPointInfoFlags &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
}
bool operator==( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( decoder_model_present_for_this_op == rhs.decoder_model_present_for_this_op ) && ( low_delay_mode_flag == rhs.low_delay_mode_flag ) &&
( initial_display_delay_present_for_this_op == rhs.initial_display_delay_present_for_this_op ) && ( reserved == rhs.reserved );
}
bool operator!=( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
uint32_t decoder_model_present_for_this_op : 1;
uint32_t low_delay_mode_flag : 1;
uint32_t initial_display_delay_present_for_this_op : 1;
uint32_t reserved : 29;
};
struct EncodeAV1OperatingPointInfo
{
using NativeType = StdVideoEncodeAV1OperatingPointInfo;
operator StdVideoEncodeAV1OperatingPointInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfo *>( this );
}
operator StdVideoEncodeAV1OperatingPointInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfo *>( this );
}
bool operator==( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( flags == rhs.flags ) && ( operating_point_idc == rhs.operating_point_idc ) && ( seq_level_idx == rhs.seq_level_idx ) &&
( seq_tier == rhs.seq_tier ) && ( decoder_buffer_delay == rhs.decoder_buffer_delay ) && ( encoder_buffer_delay == rhs.encoder_buffer_delay ) &&
( initial_display_delay_minus_1 == rhs.initial_display_delay_minus_1 );
}
bool operator!=( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags flags = {};
uint16_t operating_point_idc = {};
uint8_t seq_level_idx = {};
uint8_t seq_tier = {};
uint32_t decoder_buffer_delay = {};
uint32_t encoder_buffer_delay = {};
uint8_t initial_display_delay_minus_1 = {};
};
struct EncodeAV1PictureInfoFlags
{
using NativeType = StdVideoEncodeAV1PictureInfoFlags;
operator StdVideoEncodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoEncodeAV1PictureInfoFlags *>( this );
}
operator StdVideoEncodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoEncodeAV1PictureInfoFlags *>( this );
}
bool operator==( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) &&
( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) &&
( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) &&
( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) &&
( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) &&
( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) &&
( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) &&
( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) &&
( reduced_tx_set == rhs.reduced_tx_set ) && ( skip_mode_present == rhs.skip_mode_present ) && ( delta_q_present == rhs.delta_q_present ) &&
( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) &&
( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) &&
( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) &&
( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( show_frame == rhs.show_frame ) &&
( showable_frame == rhs.showable_frame ) && ( reserved == rhs.reserved );
}
bool operator!=( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
uint32_t error_resilient_mode : 1;
uint32_t disable_cdf_update : 1;
uint32_t use_superres : 1;
uint32_t render_and_frame_size_different : 1;
uint32_t allow_screen_content_tools : 1;
uint32_t is_filter_switchable : 1;
uint32_t force_integer_mv : 1;
uint32_t frame_size_override_flag : 1;
uint32_t buffer_removal_time_present_flag : 1;
uint32_t allow_intrabc : 1;
uint32_t frame_refs_short_signaling : 1;
uint32_t allow_high_precision_mv : 1;
uint32_t is_motion_mode_switchable : 1;
uint32_t use_ref_frame_mvs : 1;
uint32_t disable_frame_end_update_cdf : 1;
uint32_t allow_warped_motion : 1;
uint32_t reduced_tx_set : 1;
uint32_t skip_mode_present : 1;
uint32_t delta_q_present : 1;
uint32_t delta_lf_present : 1;
uint32_t delta_lf_multi : 1;
uint32_t segmentation_enabled : 1;
uint32_t segmentation_update_map : 1;
uint32_t segmentation_temporal_update : 1;
uint32_t segmentation_update_data : 1;
uint32_t UsesLr : 1;
uint32_t usesChromaLr : 1;
uint32_t show_frame : 1;
uint32_t showable_frame : 1;
uint32_t reserved : 3;
};
struct EncodeAV1PictureInfo
{
using NativeType = StdVideoEncodeAV1PictureInfo;
operator StdVideoEncodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoEncodeAV1PictureInfo *>( this );
}
operator StdVideoEncodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoEncodeAV1PictureInfo *>( this );
}
bool operator==( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( frame_presentation_time == rhs.frame_presentation_time ) &&
( current_frame_id == rhs.current_frame_id ) && ( order_hint == rhs.order_hint ) && ( primary_ref_frame == rhs.primary_ref_frame ) &&
( refresh_frame_flags == rhs.refresh_frame_flags ) && ( coded_denom == rhs.coded_denom ) &&
( render_width_minus_1 == rhs.render_width_minus_1 ) && ( render_height_minus_1 == rhs.render_height_minus_1 ) &&
( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) &&
( delta_lf_res == rhs.delta_lf_res ) && ( ref_order_hint == rhs.ref_order_hint ) && ( ref_frame_idx == rhs.ref_frame_idx ) &&
( reserved1 == rhs.reserved1 ) && ( delta_frame_id_minus_1 == rhs.delta_frame_id_minus_1 ) && ( pTileInfo == rhs.pTileInfo ) &&
( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && ( pLoopFilter == rhs.pLoopFilter ) &&
( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && ( pGlobalMotion == rhs.pGlobalMotion ) &&
( pExtensionHeader == rhs.pExtensionHeader ) && ( pBufferRemovalTimes == rhs.pBufferRemovalTimes );
}
bool operator!=( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags flags = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
uint32_t frame_presentation_time = {};
uint32_t current_frame_id = {};
uint8_t order_hint = {};
uint8_t primary_ref_frame = {};
uint8_t refresh_frame_flags = {};
uint8_t coded_denom = {};
uint16_t render_width_minus_1 = {};
uint16_t render_height_minus_1 = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter =
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap;
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4;
uint8_t delta_q_res = {};
uint8_t delta_lf_res = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> ref_order_hint = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_REFS_PER_FRAME> ref_frame_idx = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_REFS_PER_FRAME> delta_frame_id_minus_1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter * pLoopFilter = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF * pCDEF = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion * pGlobalMotion = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {};
const uint32_t * pBufferRemovalTimes = {};
};
struct EncodeAV1ReferenceInfoFlags
{
using NativeType = StdVideoEncodeAV1ReferenceInfoFlags;
operator StdVideoEncodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoEncodeAV1ReferenceInfoFlags *>( this );
}
operator StdVideoEncodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfoFlags *>( this );
}
bool operator==( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
( reserved == rhs.reserved );
}
bool operator!=( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
uint32_t disable_frame_end_update_cdf : 1;
uint32_t segmentation_enabled : 1;
uint32_t reserved : 30;
};
struct EncodeAV1ReferenceInfo
{
using NativeType = StdVideoEncodeAV1ReferenceInfo;
operator StdVideoEncodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoEncodeAV1ReferenceInfo *>( this );
}
operator StdVideoEncodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfo *>( this );
}
bool operator==( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( flags == rhs.flags ) && ( RefFrameId == rhs.RefFrameId ) && ( frame_type == rhs.frame_type ) && ( OrderHint == rhs.OrderHint ) &&
( reserved1 == rhs.reserved1 ) && ( pExtensionHeader == rhs.pExtensionHeader );
}
bool operator!=( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags flags = {};
uint32_t RefFrameId = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
uint8_t OrderHint = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {};
};
} // namespace VULKAN_HPP_VIDEO_NAMESPACE
} // namespace VULKAN_HPP_NAMESPACE
#endif

6
registry/reg.py
View file

@ -134,8 +134,10 @@ def mergeAPIs(tree, fromApiNames, toApiName):
definitionName = child.get('name')
definitionVariants = parent.findall(f"{child.tag}[@name='{definitionName}']")
elif child.tag in ['require']:
definitionName = child.get('feature')
definitionVariants = parent.findall(f"{child.tag}[@feature='{definitionName}']")
# No way to correlate require tags because they do not have a definite identifier in the way they
# are used in the latest forms of the XML so the best we can do is simply enable all of them
if child.get('api') in fromApiNames:
child.set('api', toApiName)
elif child.tag in ['command']:
definitionName = child.find('proto/name').text
definitionVariants = parent.findall(f"{child.tag}/proto/name[.='{definitionName}']/../..")

1800
registry/validusage.json
View file

File diff suppressed because it is too large Load diff

95
registry/vk.xml
View file

@ -179,11 +179,11 @@ 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> 303</type>
#define <name>VK_HEADER_VERSION</name> 304</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
#define <name>VK_HEADER_VERSION</name> 16</type>
#define <name>VK_HEADER_VERSION</name> 17</type>
<type api="vulkansc" category="define" requires="VKSC_API_VARIANT">// Complete version of this file
#define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION)</type>
@ -2042,7 +2042,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>uint32_t</type> <name>maxViewportDimensions</name>[2]<comment>max viewport dimensions (x,y)</comment></member>
<member limittype="range"><type>float</type> <name>viewportBoundsRange</name>[2]<comment>viewport bounds range (min,max)</comment></member>
<member limittype="bits"><type>uint32_t</type> <name>viewportSubPixelBits</name><comment>number bits of subpixel precision for viewport</comment></member>
<member limittype="min,pot"><type>size_t</type> <name>minMemoryMapAlignment</name><comment>min required alignment of pointers returned by MapMemory (bytes)</comment></member>
<member limittype="max,pot"><type>size_t</type> <name>minMemoryMapAlignment</name><comment>min required alignment of pointers returned by MapMemory (bytes)</comment></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>minTexelBufferOffsetAlignment</name><comment>min required alignment for texel buffer offsets (bytes) </comment></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>minUniformBufferOffsetAlignment</name><comment>min required alignment for uniform buffer sizes and offsets (bytes)</comment></member>
<member limittype="min,pot"><type>VkDeviceSize</type> <name>minStorageBufferOffsetAlignment</name><comment>min required alignment for storage buffer offsets (bytes)</comment></member>
@ -3847,7 +3847,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>blockTexelViewCompatibleMultipleLayers</name></member>
<member><type>uint32_t</type> <name>maxCombinedImageSamplerDescriptorCount</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxCombinedImageSamplerDescriptorCount</name></member>
<member limittype="bitmask"><type>VkBool32</type> <name>fragmentShadingRateClampCombinerInputs</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceMaintenance6PropertiesKHR" alias="VkPhysicalDeviceMaintenance6Properties"/>
@ -5860,7 +5860,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="bitmask"><type>VkBool32</type> <name>nonStrictSinglePixelWideLinesUseParallelogram</name></member>
<member limittype="bitmask"><type>VkBool32</type> <name>nonStrictWideLinesUseParallelogram</name></member>
<member><type>VkBool32</type> <name>blockTexelViewCompatibleMultipleLayers</name></member>
<member><type>uint32_t</type> <name>maxCombinedImageSamplerDescriptorCount</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxCombinedImageSamplerDescriptorCount</name></member>
<member limittype="bitmask"><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>
@ -11045,7 +11045,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="24" name="VK_DRIVER_ID_MESA_NVK" comment="Mesa open source project"/>
<enum value="25" name="VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA" comment="Imagination Technologies"/>
<enum value="26" name="VK_DRIVER_ID_MESA_HONEYKRISP" comment="Mesa open source project"/>
<enum value="27" name="VK_DRIVER_ID_RESERVED_27" comment="Reserved for undisclosed driver project"/>
<enum value="27" name="VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN" comment="Vulkan SC Emulation on Vulkan"/>
</enums>
<enums name="VkConditionalRenderingFlagBitsEXT" type="bitmask">
<enum bitpos="0" name="VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT"/>
@ -17959,6 +17959,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkDescriptorUpdateTemplateEntry"/>
<type name="VkDescriptorUpdateTemplateCreateInfo"/>
<enum name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET"/>
<enum name="VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO"/>
<type name="VkPushDescriptorSetWithTemplateInfo"/>
<command name="vkCmdPushDescriptorSetWithTemplate"/>
<command name="vkCmdPushDescriptorSetWithTemplate2"/>
<!-- Sparse resources are unsupported -->
<enum name="VK_QUEUE_SPARSE_BINDING_BIT"/>
@ -19018,7 +19022,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="textureCompressionASTC_HDR" struct="VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_astc_decode_mode" number="68" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_astc_decode_mode" number="68" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_astc_decode_mode&quot;" name="VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME"/>
@ -19332,7 +19336,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkCmdSetViewportWScalingNV"/>
</require>
</extension>
<extension name="VK_EXT_direct_mode_display" number="89" type="instance" depends="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_direct_mode_display" number="89" type="instance" depends="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_direct_mode_display&quot;" name="VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME"/>
@ -19347,7 +19351,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkGetRandROutputDisplayEXT"/>
</require>
</extension>
<extension name="VK_EXT_display_surface_counter" number="91" type="instance" depends="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_display_surface_counter" number="91" type="instance" depends="VK_KHR_display" author="NV" contact="James Jones @cubanismo" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_display_surface_counter&quot;" name="VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME"/>
@ -19359,7 +19363,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkGetPhysicalDeviceSurfaceCapabilities2EXT"/>
</require>
</extension>
<extension name="VK_EXT_display_control" number="92" type="device" depends="VK_EXT_display_surface_counter+VK_KHR_swapchain" author="NV" contact="James Jones @cubanismo" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_display_control" number="92" type="device" depends="VK_EXT_display_surface_counter+VK_KHR_swapchain" author="NV" contact="James Jones @cubanismo" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_DISPLAY_CONTROL_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_display_control&quot;" name="VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME"/>
@ -19473,7 +19477,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_NV_extension_101&quot;" name="VK_NV_EXTENSION_101_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_conservative_rasterization" number="102" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_conservative_rasterization" number="102" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_conservative_rasterization&quot;" name="VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME"/>
@ -19504,7 +19508,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="0" extends="VkPrivateDataSlotCreateFlagBits" name="VK_PRIVATE_DATA_SLOT_CREATE_RESERVED_0_BIT_NV"/>
</require>
</extension>
<extension name="VK_EXT_swapchain_colorspace" number="105" type="instance" depends="VK_KHR_surface" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_swapchain_colorspace" number="105" type="instance" depends="VK_KHR_surface" author="GOOGLE" contact="Courtney Goeltzenleuchter @courtney-g" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="5" name="VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_swapchain_colorspace&quot;" name="VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME"/>
@ -19835,7 +19839,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkMemoryDedicatedAllocateInfoKHR"/>
</require>
</extension>
<extension name="VK_EXT_debug_utils" number="129" type="instance" author="EXT" contact="Mark Young @marky-lunarg" specialuse="debugging" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_debug_utils" number="129" type="instance" author="EXT" contact="Mark Young @marky-lunarg" specialuse="debugging" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="2" name="VK_EXT_DEBUG_UTILS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_debug_utils&quot;" name="VK_EXT_DEBUG_UTILS_EXTENSION_NAME"/>
@ -20110,7 +20114,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkImageFormatListCreateInfoKHR"/>
</require>
</extension>
<extension name="VK_EXT_blend_operation_advanced" number="149" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_blend_operation_advanced" number="149" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="2" name="VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_blend_operation_advanced&quot;" name="VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME"/>
@ -20375,7 +20379,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="shaderSMBuiltins" struct="VkPhysicalDeviceShaderSMBuiltinsFeaturesNV"/>
</require>
</extension>
<extension name="VK_EXT_post_depth_coverage" number="156" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_post_depth_coverage" number="156" type="device" author="NV" contact="Daniel Koch @dgkoch" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_post_depth_coverage&quot;" name="VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME"/>
@ -20478,7 +20482,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkBindImageMemoryInfoKHR"/>
</require>
</extension>
<extension name="VK_EXT_image_drm_format_modifier" number="159" type="device" depends="(((VK_KHR_bind_memory2+VK_KHR_get_physical_device_properties2+VK_KHR_sampler_ycbcr_conversion),VK_VERSION_1_1)+VK_KHR_image_format_list),VK_VERSION_1_2" author="EXT" contact="Lina Versace @linyaa-kiwi" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_image_drm_format_modifier" number="159" type="device" depends="(((VK_KHR_bind_memory2+VK_KHR_get_physical_device_properties2+VK_KHR_sampler_ycbcr_conversion),VK_VERSION_1_1)+VK_KHR_image_format_list),VK_VERSION_1_2" author="EXT" contact="Lina Versace @linyaa-kiwi" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="2" name="VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_image_drm_format_modifier&quot;" name="VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME"/>
@ -20531,7 +20535,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkGetValidationCacheDataEXT"/>
</require>
</extension>
<extension name="VK_EXT_descriptor_indexing" number="162" type="device" depends="(VK_KHR_get_physical_device_properties2+VK_KHR_maintenance3),VK_VERSION_1_1" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan" promotedto="VK_VERSION_1_2">
<extension name="VK_EXT_descriptor_indexing" number="162" type="device" depends="(VK_KHR_get_physical_device_properties2+VK_KHR_maintenance3),VK_VERSION_1_1" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan" ratified="vulkan" promotedto="VK_VERSION_1_2">
<require>
<enum value="2" name="VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_descriptor_indexing&quot;" name="VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME"/>
@ -20757,7 +20761,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkCmdDrawIndexedIndirectCountKHR"/>
</require>
</extension>
<extension name="VK_EXT_filter_cubic" number="171" type="device" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_filter_cubic" number="171" type="device" author="QCOM" contact="Matthew Netsch @mnetsch" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="3" name="VK_EXT_FILTER_CUBIC_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_filter_cubic&quot;" name="VK_EXT_FILTER_CUBIC_EXTENSION_NAME"/>
@ -21107,12 +21111,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum extends="VkPipelineStageFlagBits" name="VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV" alias="VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT"/>
<command name="vkCmdDrawMeshTasksNV"/>
<command name="vkCmdDrawMeshTasksIndirectNV"/>
<command name="vkCmdDrawMeshTasksIndirectCountNV"/>
<type name="VkPhysicalDeviceMeshShaderFeaturesNV"/>
<type name="VkPhysicalDeviceMeshShaderPropertiesNV"/>
<type name="VkDrawMeshTasksIndirectCommandNV"/>
<feature name="meshShader" struct="VkPhysicalDeviceMeshShaderFeaturesNV"/>
</require>
<require depends="VK_KHR_draw_indirect_count,VK_VERSION_1_2">
<command name="vkCmdDrawMeshTasksIndirectCountNV"/>
</require>
<require depends="VK_EXT_device_generated_commands">
<enum offset="2" extends="VkIndirectCommandsTokenTypeEXT" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT"/>
<enum offset="3" extends="VkIndirectCommandsTokenTypeEXT" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT"/>
@ -21433,15 +21439,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
<require depends="VK_KHR_format_feature_flags2,VK_VERSION_1_3">
<enum bitpos="30" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
</require>
<require depends="VK_VERSION_1_3,VK_KHR_dynamic_rendering">
<enum offset="6" extends="VkStructureType" extnumber="45" name="VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"/>
</require>
<require depends="VK_VERSION_1_3,VK_KHR_dynamic_rendering" api="vulkan" comment="Remove 'api' attribute once gitlab #4074 is fixed">
<enum bitpos="21" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"/>
<enum alias="VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" extends="VkPipelineCreateFlagBits" name="VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" deprecated="aliased"/>
<enum offset="6" extends="VkStructureType" extnumber="45" name="VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"/>
<type name="VkRenderingFragmentShadingRateAttachmentInfoKHR"/>
</require>
<require depends="VK_VERSION_1_3,VK_KHR_dynamic_rendering" api="vulkansc" comment="Remove this require block once gitlab #4074 is fixed">
<enum offset="6" extends="VkStructureType" extnumber="45" name="VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR"/>
</require>
</extension>
<extension name="VK_AMD_shader_core_properties2" number="228" type="device" author="AMD" contact="Matthaeus G. Chajdas @anteru" supported="vulkan" depends="VK_AMD_shader_core_properties" nofeatures="true">
<require>
@ -21504,7 +21509,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_AMD_extension_234&quot;" name="VK_AMD_EXTENSION_234_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_shader_image_atomic_int64" number="235" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Tobias Hector @tobski" supported="vulkan,vulkansc" ratified="vulkan">
<extension name="VK_EXT_shader_image_atomic_int64" number="235" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Tobias Hector @tobski" supported="vulkan,vulkansc" ratified="vulkan,vulkansc">
<require>
<enum value="1" name="VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_shader_image_atomic_int64&quot;" name="VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME"/>
@ -21529,7 +21534,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_KHR_spirv_1_4&quot;" name="VK_KHR_SPIRV_1_4_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_memory_budget" number="238" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_memory_budget" number="238" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Jeff Bolz @jeffbolznv" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_MEMORY_BUDGET_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_memory_budget&quot;" name="VK_EXT_MEMORY_BUDGET_EXTENSION_NAME"/>
@ -21715,7 +21720,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="coverageReductionMode" struct="VkPhysicalDeviceCoverageReductionModeFeaturesNV"/>
</require>
</extension>
<extension name="VK_EXT_fragment_shader_interlock" number="252" author="EXT" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc" ratified="vulkan">
<extension name="VK_EXT_fragment_shader_interlock" number="252" author="EXT" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc" ratified="vulkan,vulkansc">
<require>
<enum value="1" name="VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_fragment_shader_interlock&quot;" name="VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME"/>
@ -21778,7 +21783,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkGetDeviceGroupSurfacePresentModes2EXT"/>
</require>
</extension>
<extension name="VK_EXT_headless_surface" number="257" type="instance" depends="VK_KHR_surface" author="EXT" contact="Lisa Wu @chengtianww" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_headless_surface" number="257" type="instance" depends="VK_KHR_surface" author="EXT" contact="Lisa Wu @chengtianww" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_HEADLESS_SURFACE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_headless_surface&quot;" name="VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME"/>
@ -22803,7 +22808,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_AMD_extension_316&quot;" name="VK_AMD_EXTENSION_316_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_descriptor_buffer" number="317" type="device" author="EXT" depends="((((VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_KHR_buffer_device_address+VK_EXT_descriptor_indexing),VK_VERSION_1_2)+VK_KHR_synchronization2),VK_VERSION_1_3" contact="Tobias Hector @tobski" supported="vulkan">
<extension name="VK_EXT_descriptor_buffer" number="317" type="device" author="EXT" depends="((((VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_KHR_buffer_device_address+VK_EXT_descriptor_indexing),VK_VERSION_1_2)+VK_KHR_synchronization2),VK_VERSION_1_3" contact="Tobias Hector @tobski" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_descriptor_buffer&quot;" name="VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME"/>
@ -22882,7 +22887,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_AMD_extension_320&quot;" name="VK_AMD_EXTENSION_320_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_graphics_pipeline_library" number="321" type="device" depends="(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_KHR_pipeline_library" author="AMD" contact="Tobias Hector @tobski" supported="vulkan">
<extension name="VK_EXT_graphics_pipeline_library" number="321" type="device" depends="(VK_KHR_get_physical_device_properties2,VK_VERSION_1_1)+VK_KHR_pipeline_library" author="AMD" contact="Tobias Hector @tobski" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_graphics_pipeline_library&quot;" name="VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME"/>
@ -23000,13 +23005,15 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="12" extends="VkQueryPipelineStatisticFlagBits" name="VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT"/>
<command name="vkCmdDrawMeshTasksEXT"/>
<command name="vkCmdDrawMeshTasksIndirectEXT"/>
<command name="vkCmdDrawMeshTasksIndirectCountEXT"/>
<type name="VkPhysicalDeviceMeshShaderFeaturesEXT"/>
<type name="VkPhysicalDeviceMeshShaderPropertiesEXT"/>
<type name="VkDrawMeshTasksIndirectCommandEXT"/>
<feature name="taskShader" struct="VkPhysicalDeviceMeshShaderFeaturesEXT"/>
<feature name="meshShader" struct="VkPhysicalDeviceMeshShaderFeaturesEXT"/>
</require>
<require depends="VK_KHR_draw_indirect_count,VK_VERSION_1_2">
<command name="vkCmdDrawMeshTasksIndirectCountEXT"/>
</require>
<require depends="VK_NV_device_generated_commands">
<enum offset="0" extends="VkIndirectCommandsTokenTypeNV" name="VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV"/>
</require>
@ -23179,7 +23186,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="formatA4R4G4B4" struct="VkPhysicalDevice4444FormatsFeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_device_fault" number="342" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Ralph Potter gitlab:@r_potter" supported="vulkan">
<extension name="VK_EXT_device_fault" number="342" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Ralph Potter gitlab:@r_potter" supported="vulkan" ratified="vulkan">
<require>
<enum value="2" name="VK_EXT_DEVICE_FAULT_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_device_fault&quot;" name="VK_EXT_DEVICE_FAULT_EXTENSION_NAME"/>
@ -23218,7 +23225,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_ARM_extension_344&quot;" name="VK_ARM_EXTENSION_344_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_rgba10x6_formats" number="345" type="device" depends="VK_KHR_sampler_ycbcr_conversion,VK_VERSION_1_1" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan">
<extension name="VK_EXT_rgba10x6_formats" number="345" type="device" depends="VK_KHR_sampler_ycbcr_conversion,VK_VERSION_1_1" author="EXT" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_rgba10x6_formats&quot;" name="VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME"/>
@ -23273,7 +23280,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="mutableDescriptorType" struct="VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE"/>
</require>
</extension>
<extension name="VK_EXT_vertex_input_dynamic_state" number="353" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc" ratified="vulkan">
<extension name="VK_EXT_vertex_input_dynamic_state" number="353" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan,vulkansc" ratified="vulkan,vulkansc">
<require>
<enum value="2" name="VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_vertex_input_dynamic_state&quot;" name="VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME"/>
@ -23625,7 +23632,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="frameBoundary" struct="VkPhysicalDeviceFrameBoundaryFeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_multisampled_render_to_single_sampled" number="377" type="device" depends="(VK_KHR_create_renderpass2+VK_KHR_depth_stencil_resolve),VK_VERSION_1_2" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan">
<extension name="VK_EXT_multisampled_render_to_single_sampled" number="377" type="device" depends="(VK_KHR_create_renderpass2+VK_KHR_depth_stencil_resolve),VK_VERSION_1_2" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_multisampled_render_to_single_sampled&quot;" name="VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME"/>
@ -24121,7 +24128,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="descriptorSetHostMapping" struct="VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE"/>
</require>
</extension>
<extension name="VK_EXT_depth_clamp_zero_one" number="422" author="EXT" type="device" contact="Graeme Leese @gnl21" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan">
<extension name="VK_EXT_depth_clamp_zero_one" number="422" author="EXT" type="device" contact="Graeme Leese @gnl21" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_depth_clamp_zero_one&quot;" name="VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME"/>
@ -24275,7 +24282,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="shaderMaximalReconvergence" struct="VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"/>
</require>
</extension>
<extension name="VK_EXT_application_parameters" number="436" type="instance" author="EXT" contact="Daniel Koch @dgkoch" supported="vulkansc" nofeatures="true">
<extension name="VK_EXT_application_parameters" number="436" type="instance" author="EXT" contact="Daniel Koch @dgkoch" supported="vulkansc" ratified="vulkansc" nofeatures="true">
<require>
<enum value="1" name="VK_EXT_APPLICATION_PARAMETERS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_application_parameters&quot;" name="VK_EXT_APPLICATION_PARAMETERS_EXTENSION_NAME"/>
@ -25296,7 +25303,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="legacyVertexAttributes" struct="VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT"/>
</require>
</extension>
<extension name="VK_EXT_layer_settings" number="497" author="EXT" contact="Christophe Riccio @christophe" type="instance" supported="vulkan,vulkansc" ratified="vulkan" nofeatures="true">
<extension name="VK_EXT_layer_settings" number="497" author="EXT" contact="Christophe Riccio @christophe" type="instance" supported="vulkan,vulkansc" ratified="vulkan,vulkansc" nofeatures="true">
<require>
<enum value="2" name="VK_EXT_LAYER_SETTINGS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_layer_settings&quot;" name="VK_EXT_LAYER_SETTINGS_EXTENSION_NAME"/>
@ -26414,7 +26421,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_KHR_extension_608&quot;" name="VK_KHR_EXTENSION_608_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_vertex_attribute_robustness" number="609" type="device" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
<extension name="VK_EXT_vertex_attribute_robustness" number="609" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="EXT" contact="Piers Daniell @pdaniell-nv" supported="vulkan">
<require>
<enum value="1" name="VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_vertex_attribute_robustness&quot;" name="VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME"/>
@ -26423,6 +26430,18 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="vertexAttributeRobustness" struct="VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"/>
</require>
</extension>
<extension name="VK_ARM_extension_610" number="610" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
<require>
<enum value="0" name="VK_ARM_EXTENSION_610_SPEC_VERSION"/>
<enum value="&quot;VK_ARM_extension_610&quot;" name="VK_ARM_EXTENSION_610_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_NV_extension_611" number="611" author="NV" contact="David Kvasnica @DaKvasNV" supported="disabled">
<require>
<enum value="0" name="VK_NV_EXTENSION_611_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extension_611&quot;" name="VK_NV_EXTENSION_611_EXTENSION_NAME"/>
</require>
</extension>
</extensions>
<formats>
<format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">