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

Update for Vulkan-Docs 1.3.244

Browse source
This commit is contained in:
Jon Leech 2023-03-17 20:45:57 -07:00
parent 65ad768d86
commit 6c5a591158
12 changed files with 952 additions and 289 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
include/vulkan/vulkan.hpp
View file

@ -114,7 +114,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 243, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 244, "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
@ -4855,6 +4855,18 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
}
//=== VK_KHR_map_memory2 ===
VkResult vkMapMemory2KHR( VkDevice device, const VkMemoryMapInfoKHR * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT
{
return ::vkMapMemory2KHR( device, pMemoryMapInfo, ppData );
}
VkResult vkUnmapMemory2KHR( VkDevice device, const VkMemoryUnmapInfoKHR * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkUnmapMemory2KHR( device, pMemoryUnmapInfo );
}
//=== VK_EXT_swapchain_maintenance1 ===
VkResult vkReleaseSwapchainImagesEXT( VkDevice device, const VkReleaseSwapchainImagesInfoEXT * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT
@ -13401,6 +13413,10 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0;
PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
//=== VK_KHR_map_memory2 ===
PFN_vkMapMemory2KHR vkMapMemory2KHR = 0;
PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0;
//=== VK_EXT_swapchain_maintenance1 ===
PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0;
@ -14632,6 +14648,10 @@ namespace VULKAN_HPP_NAMESPACE
vkGetPipelineExecutableInternalRepresentationsKHR =
PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
//=== VK_KHR_map_memory2 ===
vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetInstanceProcAddr( instance, "vkMapMemory2KHR" ) );
vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetInstanceProcAddr( instance, "vkUnmapMemory2KHR" ) );
//=== VK_EXT_swapchain_maintenance1 ===
vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetInstanceProcAddr( instance, "vkReleaseSwapchainImagesEXT" ) );
@ -15608,6 +15628,10 @@ namespace VULKAN_HPP_NAMESPACE
vkGetPipelineExecutableInternalRepresentationsKHR =
PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
//=== VK_KHR_map_memory2 ===
vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) );
vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) );
//=== VK_EXT_swapchain_maintenance1 ===
vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) );

39
include/vulkan/vulkan_core.h
View file

@ -68,7 +68,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 243
#define VK_HEADER_VERSION 244
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@ -768,6 +768,8 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,
VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,
VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,
VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000,
VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000,
VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000,
VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001,
@ -9835,6 +9837,41 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR
#endif
#define VK_KHR_map_memory2 1
#define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1
#define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2"
typedef VkFlags VkMemoryUnmapFlagsKHR;
typedef struct VkMemoryMapInfoKHR {
VkStructureType sType;
const void* pNext;
VkMemoryMapFlags flags;
VkDeviceMemory memory;
VkDeviceSize offset;
VkDeviceSize size;
} VkMemoryMapInfoKHR;
typedef struct VkMemoryUnmapInfoKHR {
VkStructureType sType;
const void* pNext;
VkMemoryUnmapFlagsKHR flags;
VkDeviceMemory memory;
} VkMemoryUnmapInfoKHR;
typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2KHR)(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData);
typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2KHR)(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR(
VkDevice device,
const VkMemoryMapInfoKHR* pMemoryMapInfo,
void** ppData);
VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR(
VkDevice device,
const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo);
#endif
#define VK_KHR_shader_integer_dot_product 1
#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION 1
#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME "VK_KHR_shader_integer_dot_product"

17
include/vulkan/vulkan_enums.hpp
View file

@ -790,6 +790,8 @@ namespace VULKAN_HPP_NAMESPACE
ePipelineExecutableInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR,
ePipelineExecutableStatisticKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR,
ePipelineExecutableInternalRepresentationKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
eMemoryMapInfoKHR = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR,
eMemoryUnmapInfoKHR = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR,
ePhysicalDeviceShaderAtomicFloat2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT,
eSurfacePresentModeEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT,
eSurfacePresentScalingCapabilitiesEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT,
@ -5593,6 +5595,21 @@ namespace VULKAN_HPP_NAMESPACE
eFloat64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR
};
//=== VK_KHR_map_memory2 ===
enum class MemoryUnmapFlagBitsKHR : VkMemoryUnmapFlagsKHR
{
};
using MemoryUnmapFlagsKHR = Flags<MemoryUnmapFlagBitsKHR>;
template <>
struct FlagTraits<MemoryUnmapFlagBitsKHR>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryUnmapFlagsKHR allFlags = {};
};
//=== VK_EXT_surface_maintenance1 ===
enum class PresentScalingFlagBitsEXT : VkPresentScalingFlagsEXT

45
include/vulkan/vulkan_funcs.hpp
View file

@ -18002,6 +18002,51 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_KHR_map_memory2 ===
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR * pMemoryMapInfo,
void ** ppData,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkMapMemory2KHR( m_device, reinterpret_cast<const VkMemoryMapInfoKHR *>( pMemoryMapInfo ), ppData ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<void *>::type
Device::mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
void * pData;
VkResult result = d.vkMapMemory2KHR( m_device, reinterpret_cast<const VkMemoryMapInfoKHR *>( &memoryMapInfo ), &pData );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2KHR" );
return createResultValueType( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), pData );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch>
VULKAN_HPP_INLINE Result Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkUnmapMemory2KHR( m_device, reinterpret_cast<const VkMemoryUnmapInfoKHR *>( pMemoryUnmapInfo ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch>
VULKAN_HPP_INLINE void Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkUnmapMemory2KHR( m_device, reinterpret_cast<const VkMemoryUnmapInfoKHR *>( &memoryUnmapInfo ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_EXT_swapchain_maintenance1 ===
template <typename Dispatch>

25
include/vulkan/vulkan_handles.hpp
View file

@ -1130,6 +1130,10 @@ namespace VULKAN_HPP_NAMESPACE
struct PipelineExecutableStatisticKHR;
struct PipelineExecutableInternalRepresentationKHR;
//=== VK_KHR_map_memory2 ===
struct MemoryMapInfoKHR;
struct MemoryUnmapInfoKHR;
//=== VK_EXT_shader_atomic_float2 ===
struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
@ -11685,6 +11689,27 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_KHR_map_memory2 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR * pMemoryMapInfo,
void ** ppData,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<void *>::type mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR * pMemoryUnmapInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_EXT_swapchain_maintenance1 ===
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>

30
include/vulkan/vulkan_hash.hpp
View file

@ -6142,6 +6142,22 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR const & memoryMapInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.flags );
VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.memory );
VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.offset );
VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfoKHR.size );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
{
@ -6207,6 +6223,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR const & memoryUnmapInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.flags );
VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfoKHR.memory );
return seed;
}
};
# if defined( VK_USE_PLATFORM_WIN32_KHR )
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>

35
include/vulkan/vulkan_raii.hpp
View file

@ -1311,6 +1311,10 @@ namespace VULKAN_HPP_NAMESPACE
vkGetPipelineExecutableInternalRepresentationsKHR =
PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
//=== VK_KHR_map_memory2 ===
vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) );
vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) );
//=== VK_EXT_swapchain_maintenance1 ===
vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) );
@ -2151,6 +2155,10 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0;
PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
//=== VK_KHR_map_memory2 ===
PFN_vkMapMemory2KHR vkMapMemory2KHR = 0;
PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0;
//=== VK_EXT_swapchain_maintenance1 ===
PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0;
@ -3933,6 +3941,12 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const;
//=== VK_KHR_map_memory2 ===
VULKAN_HPP_NODISCARD void * mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo ) const;
void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT;
//=== VK_EXT_swapchain_maintenance1 ===
void releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo ) const;
@ -17888,6 +17902,27 @@ namespace VULKAN_HPP_NAMESPACE
return internalRepresentations;
}
//=== VK_KHR_map_memory2 ===
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * Device::mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo ) const
{
VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory2KHR && "Function <vkMapMemory2KHR> requires <VK_KHR_map_memory2>" );
void * pData;
VkResult result =
getDispatcher()->vkMapMemory2KHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryMapInfoKHR *>( &memoryMapInfo ), &pData );
resultCheck( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2KHR" );
return pData;
}
VULKAN_HPP_INLINE void Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory2KHR && "Function <vkUnmapMemory2KHR> requires <VK_KHR_map_memory2>" );
getDispatcher()->vkUnmapMemory2KHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryUnmapInfoKHR *>( &memoryUnmapInfo ) );
}
//=== VK_EXT_swapchain_maintenance1 ===
VULKAN_HPP_INLINE void Device::releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo ) const

12
include/vulkan/vulkan_static_assertions.hpp
View file

@ -4488,6 +4488,18 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Pipeline
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>::value,
"PipelineExecutableInternalRepresentationKHR is not nothrow_move_constructible!" );
//=== VK_KHR_map_memory2 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR ) == sizeof( VkMemoryMapInfoKHR ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR>::value,
"MemoryMapInfoKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR ) == sizeof( VkMemoryUnmapInfoKHR ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR>::value,
"MemoryUnmapInfoKHR is not nothrow_move_constructible!" );
//=== VK_EXT_shader_atomic_float2 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT ) ==

233
include/vulkan/vulkan_structs.hpp
View file

@ -46042,6 +46042,133 @@ namespace VULKAN_HPP_NAMESPACE
using Type = MemoryHostPointerPropertiesEXT;
};
struct MemoryMapInfoKHR
{
using NativeType = VkMemoryMapInfoKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMapInfoKHR;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR MemoryMapInfoKHR( VULKAN_HPP_NAMESPACE::MemoryMapFlags flags_ = {},
VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize offset_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize size_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, flags( flags_ )
, memory( memory_ )
, offset( offset_ )
, size( size_ )
{
}
VULKAN_HPP_CONSTEXPR MemoryMapInfoKHR( MemoryMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
MemoryMapInfoKHR( VkMemoryMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryMapInfoKHR( *reinterpret_cast<MemoryMapInfoKHR const *>( &rhs ) ) {}
MemoryMapInfoKHR & operator=( MemoryMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
MemoryMapInfoKHR & operator=( VkMemoryMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 MemoryMapInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MemoryMapInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::MemoryMapFlags flags_ ) VULKAN_HPP_NOEXCEPT
{
flags = flags_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MemoryMapInfoKHR & setMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ ) VULKAN_HPP_NOEXCEPT
{
memory = memory_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MemoryMapInfoKHR & setOffset( VULKAN_HPP_NAMESPACE::DeviceSize offset_ ) VULKAN_HPP_NOEXCEPT
{
offset = offset_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MemoryMapInfoKHR & setSize( VULKAN_HPP_NAMESPACE::DeviceSize size_ ) VULKAN_HPP_NOEXCEPT
{
size = size_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkMemoryMapInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryMapInfoKHR *>( this );
}
operator VkMemoryMapInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryMapInfoKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
VULKAN_HPP_NAMESPACE::MemoryMapFlags const &,
VULKAN_HPP_NAMESPACE::DeviceMemory const &,
VULKAN_HPP_NAMESPACE::DeviceSize const &,
VULKAN_HPP_NAMESPACE::DeviceSize const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, flags, memory, offset, size );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryMapInfoKHR const & ) const = default;
#else
bool operator==( MemoryMapInfoKHR 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 ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) &&
( size == rhs.size );
# endif
}
bool operator!=( MemoryMapInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryMapInfoKHR;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::MemoryMapFlags flags = {};
VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
VULKAN_HPP_NAMESPACE::DeviceSize offset = {};
VULKAN_HPP_NAMESPACE::DeviceSize size = {};
};
template <>
struct CppType<StructureType, StructureType::eMemoryMapInfoKHR>
{
using Type = MemoryMapInfoKHR;
};
struct MemoryOpaqueCaptureAddressAllocateInfo
{
using NativeType = VkMemoryOpaqueCaptureAddressAllocateInfo;
@ -46459,6 +46586,112 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t heapIndex = {};
};
struct MemoryUnmapInfoKHR
{
using NativeType = VkMemoryUnmapInfoKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryUnmapInfoKHR;
#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR MemoryUnmapInfoKHR( VULKAN_HPP_NAMESPACE::MemoryUnmapFlagsKHR flags_ = {},
VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext( pNext_ )
, flags( flags_ )
, memory( memory_ )
{
}
VULKAN_HPP_CONSTEXPR MemoryUnmapInfoKHR( MemoryUnmapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
MemoryUnmapInfoKHR( VkMemoryUnmapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryUnmapInfoKHR( *reinterpret_cast<MemoryUnmapInfoKHR const *>( &rhs ) ) {}
MemoryUnmapInfoKHR & operator=( MemoryUnmapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
MemoryUnmapInfoKHR & operator=( VkMemoryUnmapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfoKHR & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfoKHR & setFlags( VULKAN_HPP_NAMESPACE::MemoryUnmapFlagsKHR flags_ ) VULKAN_HPP_NOEXCEPT
{
flags = flags_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfoKHR & setMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ ) VULKAN_HPP_NOEXCEPT
{
memory = memory_;
return *this;
}
#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
operator VkMemoryUnmapInfoKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkMemoryUnmapInfoKHR *>( this );
}
operator VkMemoryUnmapInfoKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkMemoryUnmapInfoKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
VULKAN_HPP_NAMESPACE::MemoryUnmapFlagsKHR const &,
VULKAN_HPP_NAMESPACE::DeviceMemory const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, flags, memory );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( MemoryUnmapInfoKHR const & ) const = default;
#else
bool operator==( MemoryUnmapInfoKHR 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 ) && ( memory == rhs.memory );
# endif
}
bool operator!=( MemoryUnmapInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eMemoryUnmapInfoKHR;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::MemoryUnmapFlagsKHR flags = {};
VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
};
template <>
struct CppType<StructureType, StructureType::eMemoryUnmapInfoKHR>
{
using Type = MemoryUnmapInfoKHR;
};
#if defined( VK_USE_PLATFORM_WIN32_KHR )
struct MemoryWin32HandlePropertiesKHR
{

16
include/vulkan/vulkan_to_string.hpp
View file

@ -2691,6 +2691,13 @@ namespace VULKAN_HPP_NAMESPACE
return "{}";
}
//=== VK_KHR_map_memory2 ===
VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagsKHR )
{
return "{}";
}
//=== VK_EXT_surface_maintenance1 ===
VULKAN_HPP_INLINE std::string to_string( PresentScalingFlagsEXT value )
@ -3840,6 +3847,8 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePipelineExecutableInfoKHR: return "PipelineExecutableInfoKHR";
case StructureType::ePipelineExecutableStatisticKHR: return "PipelineExecutableStatisticKHR";
case StructureType::ePipelineExecutableInternalRepresentationKHR: return "PipelineExecutableInternalRepresentationKHR";
case StructureType::eMemoryMapInfoKHR: return "MemoryMapInfoKHR";
case StructureType::eMemoryUnmapInfoKHR: return "MemoryUnmapInfoKHR";
case StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT: return "PhysicalDeviceShaderAtomicFloat2FeaturesEXT";
case StructureType::eSurfacePresentModeEXT: return "SurfacePresentModeEXT";
case StructureType::eSurfacePresentScalingCapabilitiesEXT: return "SurfacePresentScalingCapabilitiesEXT";
@ -7611,6 +7620,13 @@ namespace VULKAN_HPP_NAMESPACE
}
}
//=== VK_KHR_map_memory2 ===
VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlagBitsKHR )
{
return "(void)";
}
//=== VK_EXT_surface_maintenance1 ===
VULKAN_HPP_INLINE std::string to_string( PresentScalingFlagBitsEXT value )

674
registry/validusage.json
View file

File diff suppressed because it is too large Load diff

89
registry/vk.xml
View file

@ -67,7 +67,7 @@ branch of the member gitlab server.
<tag name="KHR" author="Khronos" contact="Tom Olson @tomolson"/>
<tag name="KHX" author="Khronos" contact="Tom Olson @tomolson"/>
<tag name="EXT" author="Multivendor" contact="Jon Leech @oddhack"/>
<tag name="MESA" author="Mesa open source project" contact="Chad Versace @chadversary, Daniel Stone @fooishbar, David Airlie @airlied, Faith Ekstrand @gfxstrand"/>
<tag name="MESA" author="Mesa open source project" contact="Lina Versace @versalinyaa, Daniel Stone @fooishbar, David Airlie @airlied, Faith Ekstrand @gfxstrand"/>
<tag name="INTEL" author="Intel Corporation" contact="Slawek Grajewski @sgrajewski"/>
<tag name="HUAWEI" author="Huawei Technologies Co. Ltd." contact="Pan Gao @PanGao-h, Juntao Li @Lawrenceleehw"/>
<tag name="VALVE" author="Valve Corporation" contact="Pierre-Loup Griffais @plagman, Joshua Ashton @Joshua-Ashton, Hans-Kristian Arntzen @HansKristian-Work"/>
@ -173,7 +173,7 @@ branch of the member gitlab server.
#define <name>VKSC_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0</type>
<type api="vulkan" category="define">// Version of this file
#define <name>VK_HEADER_VERSION</name> 243</type>
#define <name>VK_HEADER_VERSION</name> 244</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, 3, VK_HEADER_VERSION)</type>
<type api="vulkansc" category="define">// Version of this file
@ -510,6 +510,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type requires="VkVideoEncodeH265CapabilityFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH265CapabilityFlagsEXT</name>;</type>
<type requires="VkVideoEncodeH265CtbSizeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH265CtbSizeFlagsEXT</name>;</type>
<type requires="VkVideoEncodeH265TransformBlockSizeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH265TransformBlockSizeFlagsEXT</name>;</type>
<type category="bitmask">typedef <type>VkFlags</type> <name>VkMemoryUnmapFlagsKHR</name>;</type>
<comment>Types which can be void pointers or class pointers, selected at compile time</comment>
<type category="handle" objtypeenum="VK_OBJECT_TYPE_INSTANCE"><type>VK_DEFINE_HANDLE</type>(<name>VkInstance</name>)</type>
@ -5259,8 +5260,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max,pot"><type>uint32_t</type> <name>maxWorkGroupCount</name>[3]</member>
<member limittype="max,pot"><type>uint32_t</type> <name>maxWorkGroupSize</name>[3]</member>
<member limittype="max"><type>uint32_t</type> <name>maxOutputClusterCount</name></member>
<member limittype="exact"><type>VkDeviceSize</type> <name>indirectBufferOffsetAlignment</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxOutputClusterCount</name></member>
<member limittype="exact"><type>VkDeviceSize</type> <name>indirectBufferOffsetAlignment</name></member>
</type>
<type category="struct" name="VkMemoryOpaqueCaptureAddressAllocateInfo" structextends="VkMemoryAllocateInfo">
<member values="VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
@ -8075,6 +8076,20 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true" noautovalidity="true">const <type>void</type>* <name>pNext</name></member>
<member><type>void</type>* <name>pQueriedLowLatencyData</name></member>
</type>
<type category="struct" name="VkMemoryMapInfoKHR">
<member values="VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>VkMemoryMapFlags</type> <name>flags</name></member>
<member externsync="true"><type>VkDeviceMemory</type> <name>memory</name></member>
<member><type>VkDeviceSize</type> <name>offset</name></member>
<member><type>VkDeviceSize</type> <name>size</name></member>
</type>
<type category="struct" name="VkMemoryUnmapInfoKHR">
<member values="VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>VkMemoryUnmapFlagsKHR</type> <name>flags</name></member>
<member externsync="true"><type>VkDeviceMemory</type> <name>memory</name></member>
</type>
</types>
@ -9239,7 +9254,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="0x10004" name="VK_VENDOR_ID_CODEPLAY" comment="Codeplay Software Ltd. vendor ID"/>
<enum value="0x10005" name="VK_VENDOR_ID_MESA" comment="Mesa vendor ID"/>
<enum value="0x10006" name="VK_VENDOR_ID_POCL" comment="PoCL vendor ID"/>
<enum value="0x10007" name="VK_VENDOR_ID_MOBILEYE" comment="Mobileye vendor ID"/>
<enum value="0x10007" name="VK_VENDOR_ID_MOBILEYE" comment="Mobileye vendor ID"/>
<unused start="0x10008" comment="This is the next unused available Khronos vendor ID"/>
</enums>
<enums name="VkDriverId" type="enum">
@ -13932,6 +13947,17 @@ typedef void* <name>MTLSharedEvent_id</name>;
<param><type>VkDevice</type> <name>device</name></param>
<param>const <type>VkReleaseSwapchainImagesInfoEXT</type>* <name>pReleaseInfo</name></param>
</command>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_MEMORY_MAP_FAILED">
<proto><type>VkResult</type> <name>vkMapMemory2KHR</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param>const <type>VkMemoryMapInfoKHR</type>* <name>pMemoryMapInfo</name></param>
<param optional="false,true"><type>void</type>** <name>ppData</name></param>
</command>
<command successcodes="VK_SUCCESS">
<proto><type>VkResult</type> <name>vkUnmapMemory2KHR</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param>const <type>VkMemoryUnmapInfoKHR</type>* <name>pMemoryUnmapInfo</name></param>
</command>
</commands>
<feature api="vulkan,vulkansc" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
@ -17151,14 +17177,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_MVK_moltenvk&quot;" name="VK_MVK_MOLTENVK_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_external_memory_dma_buf" number="126" type="device" depends="VK_KHR_external_memory_fd" author="EXT" contact="Chad Versace @chadversary" supported="vulkan,vulkansc">
<extension name="VK_EXT_external_memory_dma_buf" number="126" type="device" depends="VK_KHR_external_memory_fd" author="EXT" contact="Lina Versace @versalinyaa" supported="vulkan,vulkansc">
<require>
<enum value="1" name="VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_external_memory_dma_buf&quot;" name="VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME"/>
<enum bitpos="9" extends="VkExternalMemoryHandleTypeFlagBits" name="VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT"/>
</require>
</extension>
<extension name="VK_EXT_queue_family_foreign" number="127" type="device" author="EXT" depends="VK_KHR_external_memory,VK_VERSION_1_1" contact="Chad Versace @chadversary" supported="vulkan,vulkansc">
<extension name="VK_EXT_queue_family_foreign" number="127" type="device" author="EXT" depends="VK_KHR_external_memory,VK_VERSION_1_1" contact="Lina Versace @versalinyaa" supported="vulkan,vulkansc">
<require>
<enum value="1" name="VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_queue_family_foreign&quot;" name="VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME"/>
@ -17742,7 +17768,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="Chad Versace @chadversary" supported="vulkan,vulkansc">
<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 @versalinyaa" supported="vulkan,vulkansc">
<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"/>
@ -19105,10 +19131,17 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="22" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_22_BIT_EXT"/>
</require>
</extension>
<extension name="VK_INTEL_extension_272" number="272" type="device" author="INTEL" contact="Faith Ekstrand @gfxstrand" supported="disabled">
<extension name="VK_KHR_map_memory2" number="272" type="device" author="KHR" contact="Faith Ekstrand @gfxstrand" supported="vulkan">
<require>
<enum value="0" name="VK_INTEL_EXTENSION_272_SPEC_VERSION"/>
<enum value="&quot;VK_INTEL_extension_272&quot;" name="VK_INTEL_EXTENSION_272_EXTENSION_NAME"/>
<enum value="1" name="VK_KHR_MAP_MEMORY_2_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_map_memory2&quot;" name="VK_KHR_MAP_MEMORY_2_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR"/>
<type name="VkMemoryMapInfoKHR"/>
<type name="VkMemoryUnmapInfoKHR"/>
<type name="VkMemoryUnmapFlagsKHR"/>
<command name="vkMapMemory2KHR"/>
<command name="vkUnmapMemory2KHR"/>
</require>
</extension>
<extension name="VK_INTEL_extension_273" number="273" type="device" author="INTEL" contact="Faith Ekstrand @gfxstrand" supported="disabled">
@ -21196,13 +21229,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_ARM_extension_453&quot;" name="VK_ARM_EXTENSION_453_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_GOOGLE_extension_454" number="454" author="GOOGLE" contact="Chad Versace @chadversary" supported="disabled">
<extension name="VK_GOOGLE_extension_454" number="454" author="GOOGLE" contact="Lina Versace @versalinyaa" supported="disabled">
<require>
<enum value="0" name="VK_GOOGLE_EXTENSION_454_SPEC_VERSION"/>
<enum value="&quot;VK_GOOGLE_extension_454&quot;" name="VK_GOOGLE_EXTENSION_454_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_GOOGLE_extension_455" number="455" author="GOOGLE" contact="Chad Versace @chadversary" supported="disabled">
<extension name="VK_GOOGLE_extension_455" number="455" author="GOOGLE" contact="Lina Versace @versalinyaa" supported="disabled">
<require>
<enum value="0" name="VK_GOOGLE_EXTENSION_455_SPEC_VERSION"/>
<enum value="&quot;VK_GOOGLE_extension_455&quot;" name="VK_GOOGLE_EXTENSION_455_EXTENSION_NAME"/>
@ -21813,6 +21846,36 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="6" extends="VkDescriptorSetLayoutCreateFlagBits" name="VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_6_BIT_EXT"/>
</require>
</extension>
<extension name="VK_MESA_extension_518" number="518" author="MESA" contact="Dave Airlie @airlied" type="device" supported="disabled">
<require>
<enum value="0" name="VK_MESA_EXTENSION_518_SPEC_VERSION"/>
<enum value="&quot;VK_MESA_extension_518&quot;" name="VK_MESA_EXTENSION_518_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_QCOM_extension_519" number="519" type="device" author="QCOM" contact="Jeff Leger @jackohound" supported="disabled">
<require>
<enum value="0" name="VK_QCOM_EXTENSION_519_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_extension_519&quot;" name="VK_QCOM_EXTENSION_519_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_QCOM_extension_520" number="520" type="device" author="QCOM" contact="Jeff Leger @jackohound" supported="disabled">
<require>
<enum value="0" name="VK_QCOM_EXTENSION_520_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_extension_520&quot;" name="VK_QCOM_EXTENSION_520_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_QCOM_extension_521" number="521" type="device" author="QCOM" contact="Jeff Leger @jackohound" supported="disabled">
<require>
<enum value="0" name="VK_QCOM_EXTENSION_521_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_extension_521&quot;" name="VK_QCOM_EXTENSION_521_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_QCOM_extension_522" number="522" type="device" author="QCOM" contact="Jeff Leger @jackohound" supported="disabled">
<require>
<enum value="0" name="VK_QCOM_EXTENSION_522_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_extension_522&quot;" name="VK_QCOM_EXTENSION_522_EXTENSION_NAME"/>
</require>
</extension>
</extensions>
<formats>
<format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">