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

Update for Vulkan-Docs 1.4.316

Browse source
This commit is contained in:
Jon Leech 2025-05-30 16:29:15 +01:00 • committed by Jon Leech
parent 75ad707a58
commit b11eecd68f
21 changed files with 130348 additions and 165722 deletions
Download patch file Download diff file Expand all files Collapse all files

7447
include/vulkan/vulkan.cppm
View file

File diff suppressed because it is too large Load diff

14452
include/vulkan/vulkan.hpp
View file

File diff suppressed because it is too large Load diff

92
include/vulkan/vulkan_beta.h
View file

@ -174,6 +174,98 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX(
#endif #endif
// VK_NV_cuda_kernel_launch is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_cuda_kernel_launch 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaModuleNV)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaFunctionNV)
#define VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION 2
#define VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME "VK_NV_cuda_kernel_launch"
typedef struct VkCudaModuleCreateInfoNV {
VkStructureType sType;
const void* pNext;
size_t dataSize;
const void* pData;
} VkCudaModuleCreateInfoNV;
typedef struct VkCudaFunctionCreateInfoNV {
VkStructureType sType;
const void* pNext;
VkCudaModuleNV module;
const char* pName;
} VkCudaFunctionCreateInfoNV;
typedef struct VkCudaLaunchInfoNV {
VkStructureType sType;
const void* pNext;
VkCudaFunctionNV function;
uint32_t gridDimX;
uint32_t gridDimY;
uint32_t gridDimZ;
uint32_t blockDimX;
uint32_t blockDimY;
uint32_t blockDimZ;
uint32_t sharedMemBytes;
size_t paramCount;
const void* const * pParams;
size_t extraCount;
const void* const * pExtras;
} VkCudaLaunchInfoNV;
typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV {
VkStructureType sType;
void* pNext;
VkBool32 cudaKernelLaunchFeatures;
} VkPhysicalDeviceCudaKernelLaunchFeaturesNV;
typedef struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV {
VkStructureType sType;
void* pNext;
uint32_t computeCapabilityMinor;
uint32_t computeCapabilityMajor;
} VkPhysicalDeviceCudaKernelLaunchPropertiesNV;
typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaModuleNV)(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule);
typedef VkResult (VKAPI_PTR *PFN_vkGetCudaModuleCacheNV)(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData);
typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaFunctionNV)(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction);
typedef void (VKAPI_PTR *PFN_vkDestroyCudaModuleNV)(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator);
typedef void (VKAPI_PTR *PFN_vkDestroyCudaFunctionNV)(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator);
typedef void (VKAPI_PTR *PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV(
VkDevice device,
const VkCudaModuleCreateInfoNV* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCudaModuleNV* pModule);
VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV(
VkDevice device,
VkCudaModuleNV module,
size_t* pCacheSize,
void* pCacheData);
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV(
VkDevice device,
const VkCudaFunctionCreateInfoNV* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCudaFunctionNV* pFunction);
VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV(
VkDevice device,
VkCudaModuleNV module,
const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV(
VkDevice device,
VkCudaFunctionNV function,
const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV(
VkCommandBuffer commandBuffer,
const VkCudaLaunchInfoNV* pLaunchInfo);
#endif
// VK_NV_displacement_micromap is a preprocessor guard. Do not pass it to API calls. // VK_NV_displacement_micromap is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_displacement_micromap 1 #define VK_NV_displacement_micromap 1
#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 2 #define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 2

126
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 #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 // Version of this file
#define VK_HEADER_VERSION 315 #define VK_HEADER_VERSION 316
// Complete version of this file // Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1248,6 +1248,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002, VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM = 1000609000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001,
#ifdef VK_ENABLE_BETA_EXTENSIONS #ifdef VK_ENABLE_BETA_EXTENSIONS
@ -1898,6 +1899,20 @@ typedef enum VkFormat {
VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
VK_FORMAT_R16G16_SFIXED5_NV = 1000464000, VK_FORMAT_R16G16_SFIXED5_NV = 1000464000,
VK_FORMAT_R10X6_UINT_PACK16_ARM = 1000609000,
VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM = 1000609001,
VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM = 1000609002,
VK_FORMAT_R12X4_UINT_PACK16_ARM = 1000609003,
VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM = 1000609004,
VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM = 1000609005,
VK_FORMAT_R14X2_UINT_PACK16_ARM = 1000609006,
VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM = 1000609007,
VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM = 1000609008,
VK_FORMAT_R14X2_UNORM_PACK16_ARM = 1000609009,
VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM = 1000609010,
VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM = 1000609011,
VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM = 1000609012,
VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM = 1000609013,
VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK,
VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK,
VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK,
@ -17121,98 +17136,6 @@ typedef struct VkDeviceDiagnosticsConfigCreateInfoNV {
#define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops" #define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops"
// VK_NV_cuda_kernel_launch is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_cuda_kernel_launch 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaModuleNV)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaFunctionNV)
#define VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION 2
#define VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME "VK_NV_cuda_kernel_launch"
typedef struct VkCudaModuleCreateInfoNV {
VkStructureType sType;
const void* pNext;
size_t dataSize;
const void* pData;
} VkCudaModuleCreateInfoNV;
typedef struct VkCudaFunctionCreateInfoNV {
VkStructureType sType;
const void* pNext;
VkCudaModuleNV module;
const char* pName;
} VkCudaFunctionCreateInfoNV;
typedef struct VkCudaLaunchInfoNV {
VkStructureType sType;
const void* pNext;
VkCudaFunctionNV function;
uint32_t gridDimX;
uint32_t gridDimY;
uint32_t gridDimZ;
uint32_t blockDimX;
uint32_t blockDimY;
uint32_t blockDimZ;
uint32_t sharedMemBytes;
size_t paramCount;
const void* const * pParams;
size_t extraCount;
const void* const * pExtras;
} VkCudaLaunchInfoNV;
typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV {
VkStructureType sType;
void* pNext;
VkBool32 cudaKernelLaunchFeatures;
} VkPhysicalDeviceCudaKernelLaunchFeaturesNV;
typedef struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV {
VkStructureType sType;
void* pNext;
uint32_t computeCapabilityMinor;
uint32_t computeCapabilityMajor;
} VkPhysicalDeviceCudaKernelLaunchPropertiesNV;
typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaModuleNV)(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule);
typedef VkResult (VKAPI_PTR *PFN_vkGetCudaModuleCacheNV)(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData);
typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaFunctionNV)(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction);
typedef void (VKAPI_PTR *PFN_vkDestroyCudaModuleNV)(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator);
typedef void (VKAPI_PTR *PFN_vkDestroyCudaFunctionNV)(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator);
typedef void (VKAPI_PTR *PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV(
VkDevice device,
const VkCudaModuleCreateInfoNV* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCudaModuleNV* pModule);
VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV(
VkDevice device,
VkCudaModuleNV module,
size_t* pCacheSize,
void* pCacheData);
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV(
VkDevice device,
const VkCudaFunctionCreateInfoNV* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCudaFunctionNV* pFunction);
VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV(
VkDevice device,
VkCudaModuleNV module,
const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV(
VkDevice device,
VkCudaFunctionNV function,
const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV(
VkCommandBuffer commandBuffer,
const VkCudaLaunchInfoNV* pLaunchInfo);
#endif
// VK_QCOM_tile_shading is a preprocessor guard. Do not pass it to API calls. // VK_QCOM_tile_shading is a preprocessor guard. Do not pass it to API calls.
#define VK_QCOM_tile_shading 1 #define VK_QCOM_tile_shading 1
#define VK_QCOM_TILE_SHADING_SPEC_VERSION 1 #define VK_QCOM_TILE_SHADING_SPEC_VERSION 1
@ -17274,13 +17197,14 @@ typedef struct VkDispatchTileInfoQCOM {
const void* pNext; const void* pNext;
} VkDispatchTileInfoQCOM; } VkDispatchTileInfoQCOM;
typedef void (VKAPI_PTR *PFN_vkCmdDispatchTileQCOM)(VkCommandBuffer commandBuffer); typedef void (VKAPI_PTR *PFN_vkCmdDispatchTileQCOM)(VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo);
typedef void (VKAPI_PTR *PFN_vkCmdBeginPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo); typedef void (VKAPI_PTR *PFN_vkCmdBeginPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo);
typedef void (VKAPI_PTR *PFN_vkCmdEndPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo); typedef void (VKAPI_PTR *PFN_vkCmdEndPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo);
#ifndef VK_NO_PROTOTYPES #ifndef VK_NO_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM( VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM(
VkCommandBuffer commandBuffer); VkCommandBuffer commandBuffer,
const VkDispatchTileInfoQCOM* pDispatchTileInfo);
VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM( VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM(
VkCommandBuffer commandBuffer, VkCommandBuffer commandBuffer,
@ -21609,6 +21533,18 @@ typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
// VK_ARM_format_pack is a preprocessor guard. Do not pass it to API calls.
#define VK_ARM_format_pack 1
#define VK_ARM_FORMAT_PACK_SPEC_VERSION 1
#define VK_ARM_FORMAT_PACK_EXTENSION_NAME "VK_ARM_format_pack"
typedef struct VkPhysicalDeviceFormatPackFeaturesARM {
VkStructureType sType;
void* pNext;
VkBool32 formatPack;
} VkPhysicalDeviceFormatPackFeaturesARM;
// VK_NV_present_metering is a preprocessor guard. Do not pass it to API calls. // VK_NV_present_metering is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_present_metering 1 #define VK_NV_present_metering 1
#define VK_NV_PRESENT_METERING_SPEC_VERSION 1 #define VK_NV_PRESENT_METERING_SPEC_VERSION 1

4665
include/vulkan/vulkan_enums.hpp
View file

File diff suppressed because it is too large Load diff

3607
include/vulkan/vulkan_extension_inspection.hpp
View file

File diff suppressed because it is too large Load diff

1349
include/vulkan/vulkan_format_traits.hpp
View file

File diff suppressed because one or more lines are too long

20378
include/vulkan/vulkan_funcs.hpp
View file

File diff suppressed because it is too large Load diff

12753
include/vulkan/vulkan_handles.hpp
View file

File diff suppressed because it is too large Load diff

4998
include/vulkan/vulkan_hash.hpp
View file

File diff suppressed because it is too large Load diff

5
include/vulkan/vulkan_hpp_macros.hpp
View file

@ -5,6 +5,7 @@
// This header is generated from the Khronos Vulkan XML API Registry. // This header is generated from the Khronos Vulkan XML API Registry.
#ifndef VULKAN_HPP_MACROS_HPP #ifndef VULKAN_HPP_MACROS_HPP
#define VULKAN_HPP_MACROS_HPP #define VULKAN_HPP_MACROS_HPP
@ -92,8 +93,7 @@
#endif #endif
#ifndef VK_USE_64_BIT_PTR_DEFINES #ifndef VK_USE_64_BIT_PTR_DEFINES
# if defined( __LP64__ ) || defined( _WIN64 ) || ( defined( __x86_64__ ) && !defined( __ILP32__ ) ) || defined( _M_X64 ) || defined( __ia64 ) || \ #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) || (defined(__riscv) && __riscv_xlen == 64)
defined( _M_IA64 ) || defined( __aarch64__ ) || defined( __powerpc64__ ) || ( defined( __riscv ) && __riscv_xlen == 64 )
#define VK_USE_64_BIT_PTR_DEFINES 1 #define VK_USE_64_BIT_PTR_DEFINES 1
#else #else
#define VK_USE_64_BIT_PTR_DEFINES 0 #define VK_USE_64_BIT_PTR_DEFINES 0
@ -323,4 +323,5 @@ namespace VULKAN_HPP_NAMESPACE
# define VULKAN_HPP_RAII_CREATE_NOEXCEPT # define VULKAN_HPP_RAII_CREATE_NOEXCEPT
#endif #endif
#endif #endif

16050
include/vulkan/vulkan_raii.hpp
View file

File diff suppressed because it is too large Load diff

109
include/vulkan/vulkan_shared.hpp
View file

@ -327,8 +327,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType; using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
template <class Dispatcher> template <class Dispatcher>
using DestroyFunctionPointerType = using DestroyFunctionPointerType = typename std::conditional<HasDestructor<HandleType>::value,
typename std::conditional<HasDestructor<HandleType>::value,
void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const, void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type; void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
@ -466,12 +465,13 @@ namespace VULKAN_HPP_NAMESPACE
# pragma clang diagnostic pop # pragma clang diagnostic pop
#endif #endif
} // namespace detail }
//====================== //======================
//=== SHARED HANDLEs === //=== SHARED HANDLEs ===
//====================== //======================
//=== VK_VERSION_1_0 === //=== VK_VERSION_1_0 ===
template <> template <>
class SharedHandleTraits<Instance> class SharedHandleTraits<Instance>
@ -480,9 +480,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = NoDestructor; using DestructorType = NoDestructor;
using deleter = detail::ObjectDestroyShared<Instance>; using deleter = detail::ObjectDestroyShared<Instance>;
}; };
using SharedInstance = SharedHandle<Instance>; using SharedInstance = SharedHandle<Instance>;
template <> template <>
class SharedHandleTraits<Device> class SharedHandleTraits<Device>
{ {
@ -490,9 +488,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = NoDestructor; using DestructorType = NoDestructor;
using deleter = detail::ObjectDestroyShared<Device>; using deleter = detail::ObjectDestroyShared<Device>;
}; };
using SharedDevice = SharedHandle<Device>; using SharedDevice = SharedHandle<Device>;
template <> template <>
class SharedHandleTraits<DeviceMemory> class SharedHandleTraits<DeviceMemory>
{ {
@ -500,9 +496,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectFreeShared<DeviceMemory>; using deleter = detail::ObjectFreeShared<DeviceMemory>;
}; };
using SharedDeviceMemory = SharedHandle<DeviceMemory>; using SharedDeviceMemory = SharedHandle<DeviceMemory>;
template <> template <>
class SharedHandleTraits<Fence> class SharedHandleTraits<Fence>
{ {
@ -510,9 +504,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Fence>; using deleter = detail::ObjectDestroyShared<Fence>;
}; };
using SharedFence = SharedHandle<Fence>; using SharedFence = SharedHandle<Fence>;
template <> template <>
class SharedHandleTraits<Semaphore> class SharedHandleTraits<Semaphore>
{ {
@ -520,9 +512,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Semaphore>; using deleter = detail::ObjectDestroyShared<Semaphore>;
}; };
using SharedSemaphore = SharedHandle<Semaphore>; using SharedSemaphore = SharedHandle<Semaphore>;
template <> template <>
class SharedHandleTraits<Event> class SharedHandleTraits<Event>
{ {
@ -530,9 +520,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Event>; using deleter = detail::ObjectDestroyShared<Event>;
}; };
using SharedEvent = SharedHandle<Event>; using SharedEvent = SharedHandle<Event>;
template <> template <>
class SharedHandleTraits<QueryPool> class SharedHandleTraits<QueryPool>
{ {
@ -540,9 +528,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<QueryPool>; using deleter = detail::ObjectDestroyShared<QueryPool>;
}; };
using SharedQueryPool = SharedHandle<QueryPool>; using SharedQueryPool = SharedHandle<QueryPool>;
template <> template <>
class SharedHandleTraits<Buffer> class SharedHandleTraits<Buffer>
{ {
@ -550,9 +536,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Buffer>; using deleter = detail::ObjectDestroyShared<Buffer>;
}; };
using SharedBuffer = SharedHandle<Buffer>; using SharedBuffer = SharedHandle<Buffer>;
template <> template <>
class SharedHandleTraits<BufferView> class SharedHandleTraits<BufferView>
{ {
@ -560,9 +544,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<BufferView>; using deleter = detail::ObjectDestroyShared<BufferView>;
}; };
using SharedBufferView = SharedHandle<BufferView>; using SharedBufferView = SharedHandle<BufferView>;
template <> template <>
class SharedHandleTraits<Image> class SharedHandleTraits<Image>
{ {
@ -570,9 +552,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Image>; using deleter = detail::ObjectDestroyShared<Image>;
}; };
using SharedImage = SharedHandle<Image>; using SharedImage = SharedHandle<Image>;
template <> template <>
class SharedHandleTraits<ImageView> class SharedHandleTraits<ImageView>
{ {
@ -580,9 +560,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<ImageView>; using deleter = detail::ObjectDestroyShared<ImageView>;
}; };
using SharedImageView = SharedHandle<ImageView>; using SharedImageView = SharedHandle<ImageView>;
template <> template <>
class SharedHandleTraits<ShaderModule> class SharedHandleTraits<ShaderModule>
{ {
@ -590,9 +568,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<ShaderModule>; using deleter = detail::ObjectDestroyShared<ShaderModule>;
}; };
using SharedShaderModule = SharedHandle<ShaderModule>; using SharedShaderModule = SharedHandle<ShaderModule>;
template <> template <>
class SharedHandleTraits<PipelineCache> class SharedHandleTraits<PipelineCache>
{ {
@ -600,9 +576,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<PipelineCache>; using deleter = detail::ObjectDestroyShared<PipelineCache>;
}; };
using SharedPipelineCache = SharedHandle<PipelineCache>; using SharedPipelineCache = SharedHandle<PipelineCache>;
template <> template <>
class SharedHandleTraits<Pipeline> class SharedHandleTraits<Pipeline>
{ {
@ -610,9 +584,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Pipeline>; using deleter = detail::ObjectDestroyShared<Pipeline>;
}; };
using SharedPipeline = SharedHandle<Pipeline>; using SharedPipeline = SharedHandle<Pipeline>;
template <> template <>
class SharedHandleTraits<PipelineLayout> class SharedHandleTraits<PipelineLayout>
{ {
@ -620,9 +592,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<PipelineLayout>; using deleter = detail::ObjectDestroyShared<PipelineLayout>;
}; };
using SharedPipelineLayout = SharedHandle<PipelineLayout>; using SharedPipelineLayout = SharedHandle<PipelineLayout>;
template <> template <>
class SharedHandleTraits<Sampler> class SharedHandleTraits<Sampler>
{ {
@ -630,9 +600,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Sampler>; using deleter = detail::ObjectDestroyShared<Sampler>;
}; };
using SharedSampler = SharedHandle<Sampler>; using SharedSampler = SharedHandle<Sampler>;
template <> template <>
class SharedHandleTraits<DescriptorPool> class SharedHandleTraits<DescriptorPool>
{ {
@ -640,9 +608,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<DescriptorPool>; using deleter = detail::ObjectDestroyShared<DescriptorPool>;
}; };
using SharedDescriptorPool = SharedHandle<DescriptorPool>; using SharedDescriptorPool = SharedHandle<DescriptorPool>;
template <> template <>
class SharedHandleTraits<DescriptorSet> class SharedHandleTraits<DescriptorSet>
{ {
@ -650,9 +616,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::PoolFreeShared<DescriptorSet, DescriptorPool>; using deleter = detail::PoolFreeShared<DescriptorSet, DescriptorPool>;
}; };
using SharedDescriptorSet = SharedHandle<DescriptorSet>; using SharedDescriptorSet = SharedHandle<DescriptorSet>;
template <> template <>
class SharedHandleTraits<DescriptorSetLayout> class SharedHandleTraits<DescriptorSetLayout>
{ {
@ -660,9 +624,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<DescriptorSetLayout>; using deleter = detail::ObjectDestroyShared<DescriptorSetLayout>;
}; };
using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>; using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
template <> template <>
class SharedHandleTraits<Framebuffer> class SharedHandleTraits<Framebuffer>
{ {
@ -670,9 +632,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Framebuffer>; using deleter = detail::ObjectDestroyShared<Framebuffer>;
}; };
using SharedFramebuffer = SharedHandle<Framebuffer>; using SharedFramebuffer = SharedHandle<Framebuffer>;
template <> template <>
class SharedHandleTraits<RenderPass> class SharedHandleTraits<RenderPass>
{ {
@ -680,9 +640,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<RenderPass>; using deleter = detail::ObjectDestroyShared<RenderPass>;
}; };
using SharedRenderPass = SharedHandle<RenderPass>; using SharedRenderPass = SharedHandle<RenderPass>;
template <> template <>
class SharedHandleTraits<CommandPool> class SharedHandleTraits<CommandPool>
{ {
@ -690,9 +648,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<CommandPool>; using deleter = detail::ObjectDestroyShared<CommandPool>;
}; };
using SharedCommandPool = SharedHandle<CommandPool>; using SharedCommandPool = SharedHandle<CommandPool>;
template <> template <>
class SharedHandleTraits<CommandBuffer> class SharedHandleTraits<CommandBuffer>
{ {
@ -700,7 +656,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::PoolFreeShared<CommandBuffer, CommandPool>; using deleter = detail::PoolFreeShared<CommandBuffer, CommandPool>;
}; };
using SharedCommandBuffer = SharedHandle<CommandBuffer>; using SharedCommandBuffer = SharedHandle<CommandBuffer>;
//=== VK_VERSION_1_1 === //=== VK_VERSION_1_1 ===
@ -711,21 +666,16 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<SamplerYcbcrConversion>; using deleter = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
}; };
using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>; using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>; using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>; template <>
template <>
class SharedHandleTraits<DescriptorUpdateTemplate> class SharedHandleTraits<DescriptorUpdateTemplate>
{ {
public: public:
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<DescriptorUpdateTemplate>; using deleter = detail::ObjectDestroyShared<DescriptorUpdateTemplate>;
}; };
using SharedDescriptorUpdateTemplate = SharedHandle<DescriptorUpdateTemplate>; using SharedDescriptorUpdateTemplate = SharedHandle<DescriptorUpdateTemplate>;
using SharedDescriptorUpdateTemplateKHR = SharedHandle<DescriptorUpdateTemplate>; using SharedDescriptorUpdateTemplateKHR = SharedHandle<DescriptorUpdateTemplate>;
//=== VK_VERSION_1_3 === //=== VK_VERSION_1_3 ===
template <> template <>
class SharedHandleTraits<PrivateDataSlot> class SharedHandleTraits<PrivateDataSlot>
@ -734,10 +684,8 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<PrivateDataSlot>; using deleter = detail::ObjectDestroyShared<PrivateDataSlot>;
}; };
using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>; using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>;
using SharedPrivateDataSlotEXT = SharedHandle<PrivateDataSlot>; using SharedPrivateDataSlotEXT = SharedHandle<PrivateDataSlot>;
//=== VK_KHR_surface === //=== VK_KHR_surface ===
template <> template <>
class SharedHandleTraits<SurfaceKHR> class SharedHandleTraits<SurfaceKHR>
@ -746,7 +694,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Instance; using DestructorType = Instance;
using deleter = detail::ObjectDestroyShared<SurfaceKHR>; using deleter = detail::ObjectDestroyShared<SurfaceKHR>;
}; };
using SharedSurfaceKHR = SharedHandle<SurfaceKHR>; using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
//=== VK_KHR_swapchain === //=== VK_KHR_swapchain ===
@ -757,7 +704,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<SwapchainKHR>; using deleter = detail::ObjectDestroyShared<SwapchainKHR>;
}; };
using SharedSwapchainKHR = SharedHandle<SwapchainKHR>; using SharedSwapchainKHR = SharedHandle<SwapchainKHR>;
//=== VK_KHR_display === //=== VK_KHR_display ===
@ -768,7 +714,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = PhysicalDevice; using DestructorType = PhysicalDevice;
using deleter = detail::ObjectDestroyShared<DisplayKHR>; using deleter = detail::ObjectDestroyShared<DisplayKHR>;
}; };
using SharedDisplayKHR = SharedHandle<DisplayKHR>; using SharedDisplayKHR = SharedHandle<DisplayKHR>;
//=== VK_EXT_debug_report === //=== VK_EXT_debug_report ===
@ -779,7 +724,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Instance; using DestructorType = Instance;
using deleter = detail::ObjectDestroyShared<DebugReportCallbackEXT>; using deleter = detail::ObjectDestroyShared<DebugReportCallbackEXT>;
}; };
using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>; using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>;
//=== VK_KHR_video_queue === //=== VK_KHR_video_queue ===
@ -790,9 +734,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<VideoSessionKHR>; using deleter = detail::ObjectDestroyShared<VideoSessionKHR>;
}; };
using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>; using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>;
template <> template <>
class SharedHandleTraits<VideoSessionParametersKHR> class SharedHandleTraits<VideoSessionParametersKHR>
{ {
@ -800,7 +742,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<VideoSessionParametersKHR>; using deleter = detail::ObjectDestroyShared<VideoSessionParametersKHR>;
}; };
using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>; using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>;
//=== VK_NVX_binary_import === //=== VK_NVX_binary_import ===
@ -811,9 +752,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<CuModuleNVX>; using deleter = detail::ObjectDestroyShared<CuModuleNVX>;
}; };
using SharedCuModuleNVX = SharedHandle<CuModuleNVX>; using SharedCuModuleNVX = SharedHandle<CuModuleNVX>;
template <> template <>
class SharedHandleTraits<CuFunctionNVX> class SharedHandleTraits<CuFunctionNVX>
{ {
@ -821,7 +760,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<CuFunctionNVX>; using deleter = detail::ObjectDestroyShared<CuFunctionNVX>;
}; };
using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>; using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>;
//=== VK_EXT_debug_utils === //=== VK_EXT_debug_utils ===
@ -832,7 +770,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Instance; using DestructorType = Instance;
using deleter = detail::ObjectDestroyShared<DebugUtilsMessengerEXT>; using deleter = detail::ObjectDestroyShared<DebugUtilsMessengerEXT>;
}; };
using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>; using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
//=== VK_KHR_acceleration_structure === //=== VK_KHR_acceleration_structure ===
@ -843,7 +780,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<AccelerationStructureKHR>; using deleter = detail::ObjectDestroyShared<AccelerationStructureKHR>;
}; };
using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>; using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>;
//=== VK_EXT_validation_cache === //=== VK_EXT_validation_cache ===
@ -854,7 +790,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<ValidationCacheEXT>; using deleter = detail::ObjectDestroyShared<ValidationCacheEXT>;
}; };
using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>; using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>;
//=== VK_NV_ray_tracing === //=== VK_NV_ray_tracing ===
@ -865,7 +800,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<AccelerationStructureNV>; using deleter = detail::ObjectDestroyShared<AccelerationStructureNV>;
}; };
using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>; using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>;
//=== VK_INTEL_performance_query === //=== VK_INTEL_performance_query ===
@ -876,7 +810,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<PerformanceConfigurationINTEL>; using deleter = detail::ObjectDestroyShared<PerformanceConfigurationINTEL>;
}; };
using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>; using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>;
//=== VK_KHR_deferred_host_operations === //=== VK_KHR_deferred_host_operations ===
@ -887,7 +820,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<DeferredOperationKHR>; using deleter = detail::ObjectDestroyShared<DeferredOperationKHR>;
}; };
using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>; using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>;
//=== VK_NV_device_generated_commands === //=== VK_NV_device_generated_commands ===
@ -898,7 +830,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<IndirectCommandsLayoutNV>; using deleter = detail::ObjectDestroyShared<IndirectCommandsLayoutNV>;
}; };
using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>; using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>;
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
@ -910,9 +841,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<CudaModuleNV>; using deleter = detail::ObjectDestroyShared<CudaModuleNV>;
}; };
using SharedCudaModuleNV = SharedHandle<CudaModuleNV>; using SharedCudaModuleNV = SharedHandle<CudaModuleNV>;
template <> template <>
class SharedHandleTraits<CudaFunctionNV> class SharedHandleTraits<CudaFunctionNV>
{ {
@ -920,7 +849,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<CudaFunctionNV>; using deleter = detail::ObjectDestroyShared<CudaFunctionNV>;
}; };
using SharedCudaFunctionNV = SharedHandle<CudaFunctionNV>; using SharedCudaFunctionNV = SharedHandle<CudaFunctionNV>;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -933,7 +861,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<BufferCollectionFUCHSIA>; using deleter = detail::ObjectDestroyShared<BufferCollectionFUCHSIA>;
}; };
using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>; using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>;
#endif /*VK_USE_PLATFORM_FUCHSIA*/ #endif /*VK_USE_PLATFORM_FUCHSIA*/
@ -945,7 +872,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<MicromapEXT>; using deleter = detail::ObjectDestroyShared<MicromapEXT>;
}; };
using SharedMicromapEXT = SharedHandle<MicromapEXT>; using SharedMicromapEXT = SharedHandle<MicromapEXT>;
//=== VK_NV_optical_flow === //=== VK_NV_optical_flow ===
@ -956,7 +882,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<OpticalFlowSessionNV>; using deleter = detail::ObjectDestroyShared<OpticalFlowSessionNV>;
}; };
using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>; using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>;
//=== VK_EXT_shader_object === //=== VK_EXT_shader_object ===
@ -967,7 +892,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<ShaderEXT>; using deleter = detail::ObjectDestroyShared<ShaderEXT>;
}; };
using SharedShaderEXT = SharedHandle<ShaderEXT>; using SharedShaderEXT = SharedHandle<ShaderEXT>;
//=== VK_KHR_pipeline_binary === //=== VK_KHR_pipeline_binary ===
@ -978,7 +902,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<PipelineBinaryKHR>; using deleter = detail::ObjectDestroyShared<PipelineBinaryKHR>;
}; };
using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>; using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>;
//=== VK_NV_external_compute_queue === //=== VK_NV_external_compute_queue ===
@ -989,7 +912,6 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<ExternalComputeQueueNV>; using deleter = detail::ObjectDestroyShared<ExternalComputeQueueNV>;
}; };
using SharedExternalComputeQueueNV = SharedHandle<ExternalComputeQueueNV>; using SharedExternalComputeQueueNV = SharedHandle<ExternalComputeQueueNV>;
//=== VK_EXT_device_generated_commands === //=== VK_EXT_device_generated_commands ===
@ -1000,9 +922,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<IndirectCommandsLayoutEXT>; using deleter = detail::ObjectDestroyShared<IndirectCommandsLayoutEXT>;
}; };
using SharedIndirectCommandsLayoutEXT = SharedHandle<IndirectCommandsLayoutEXT>; using SharedIndirectCommandsLayoutEXT = SharedHandle<IndirectCommandsLayoutEXT>;
template <> template <>
class SharedHandleTraits<IndirectExecutionSetEXT> class SharedHandleTraits<IndirectExecutionSetEXT>
{ {
@ -1010,9 +930,9 @@ namespace VULKAN_HPP_NAMESPACE
using DestructorType = Device; using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<IndirectExecutionSetEXT>; using deleter = detail::ObjectDestroyShared<IndirectExecutionSetEXT>;
}; };
using SharedIndirectExecutionSetEXT = SharedHandle<IndirectExecutionSetEXT>; using SharedIndirectExecutionSetEXT = SharedHandle<IndirectExecutionSetEXT>;
enum class SwapchainOwns enum class SwapchainOwns
{ {
no, no,
@ -1021,8 +941,7 @@ namespace VULKAN_HPP_NAMESPACE
struct ImageHeader : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter> struct ImageHeader : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>
{ {
ImageHeader( ImageHeader( SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter deleter = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter(), typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter deleter = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter(),
SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
: SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>( std::move( parent ), : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>( std::move( parent ),
@ -1131,13 +1050,10 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
SharedHandle() = default; SharedHandle() = default;
explicit SharedHandle(PhysicalDevice handle, SharedInstance parent) noexcept explicit SharedHandle(PhysicalDevice handle, SharedInstance parent) noexcept
: SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>(handle, std::move(parent)) : SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>(handle, std::move(parent))
{ {}
}
}; };
using SharedPhysicalDevice = SharedHandle<PhysicalDevice>; using SharedPhysicalDevice = SharedHandle<PhysicalDevice>;
template <> template <>
@ -1147,10 +1063,10 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
SharedHandle() = default; SharedHandle() = default;
explicit SharedHandle(Queue handle, SharedDevice parent) noexcept
explicit SharedHandle( Queue handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy<Queue, SharedDevice>( handle, std::move( parent ) ) {} : SharedHandleBaseNoDestroy<Queue, SharedDevice>(handle, std::move(parent))
{}
}; };
using SharedQueue = SharedHandle<Queue>; using SharedQueue = SharedHandle<Queue>;
//=== VK_KHR_display === //=== VK_KHR_display ===
@ -1162,13 +1078,10 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
SharedHandle() = default; SharedHandle() = default;
explicit SharedHandle(DisplayModeKHR handle, SharedDisplayKHR parent) noexcept explicit SharedHandle(DisplayModeKHR handle, SharedDisplayKHR parent) noexcept
: SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>(handle, std::move(parent)) : SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>(handle, std::move(parent))
{ {}
}
}; };
using SharedDisplayModeKHR = SharedHandle<DisplayModeKHR>; using SharedDisplayModeKHR = SharedHandle<DisplayModeKHR>;
#endif // !VULKAN_HPP_NO_SMART_HANDLE #endif // !VULKAN_HPP_NO_SMART_HANDLE
} // namespace VULKAN_HPP_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE

8687
include/vulkan/vulkan_static_assertions.hpp
View file

File diff suppressed because it is too large Load diff

52962
include/vulkan/vulkan_structs.hpp
View file

File diff suppressed because one or more lines are too long

3488
include/vulkan/vulkan_to_string.hpp
View file

File diff suppressed because it is too large Load diff

157
include/vulkan/vulkan_video.cppm Normal file
View file

@ -0,0 +1,157 @@
// Copyright 2021-2025 The Khronos Group Inc.
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
// This header is generated from the Khronos Vulkan XML API Registry.
// Note: This module is still in an experimental state.
// Any feedback is welcome on https://github.com/KhronosGroup/Vulkan-Hpp/issues.
module;
#include <vulkan/vulkan_hpp_macros.hpp>
#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
# define VULKAN_HPP_ENABLE_STD_MODULE
#endif
#include <vulkan/vulkan_video.hpp>
export module vulkan_video_hpp;
export namespace VULKAN_HPP_NAMESPACE
{
namespace VULKAN_HPP_VIDEO_NAMESPACE
{
//=============
//=== ENUMs ===
//=============
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NonVclNaluType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType;
//===============
//=== STRUCTS ===
//===============
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags;
} // namespace VULKAN_HPP_VIDEO_NAMESPACE
} // namespace VULKAN_HPP_NAMESPACE

141
registry/base_generator.py
View file

@ -9,7 +9,7 @@ import os
import tempfile import tempfile
from vulkan_object import (VulkanObject, from vulkan_object import (VulkanObject,
Extension, Version, Handle, Param, Queues, CommandScope, Command, Extension, Version, Handle, Param, Queues, CommandScope, Command,
EnumField, Enum, Flag, Bitmask, Member, Struct, EnumField, Enum, Flag, Bitmask, Flags, Member, Struct,
FormatComponent, FormatPlane, Format, FormatComponent, FormatPlane, Format,
SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline, SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline,
SpirvEnables, Spirv) SpirvEnables, Spirv)
@ -146,9 +146,26 @@ class BaseGenerator(OutputGenerator):
self.enumFieldAliasMap = dict() self.enumFieldAliasMap = dict()
self.bitmaskAliasMap = dict() self.bitmaskAliasMap = dict()
self.flagAliasMap = dict() self.flagAliasMap = dict()
self.flagsAliasMap = dict()
self.structAliasMap = dict() self.structAliasMap = dict()
self.handleAliasMap = dict() self.handleAliasMap = dict()
# We track all enum constants and flag bits so that we can apply their aliases in the end
self.enumFieldMap: dict[str, EnumField] = dict()
self.flagMap: dict[str, Flag] = dict()
# De-aliases a definition name based on the specified alias map.
# There are aliases of aliases.
# e.g. VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR aliases
# VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR which itself aliases
# But it is also common for EXT types promoted to KHR then to core.
# We should not make assumptions about the nesting level of aliases, instead we resolve any
# level of alias aliasing.
def dealias(self, name: str, aliasMap: dict):
while name in aliasMap:
name = aliasMap[name]
return name
def write(self, data): def write(self, data):
# Prevents having to check before writing # Prevents having to check before writing
if data is not None and data != "": if data is not None and data != "":
@ -212,7 +229,7 @@ class BaseGenerator(OutputGenerator):
command = self.vk.commands[commandName] command = self.vk.commands[commandName]
# Make sure list is unique # Make sure list is unique
command.extensions.extend([extension] if extension not in command.extensions else []) command.extensions.extend([extension.name] if extension.name not in command.extensions else [])
extension.commands.extend([command] if command not in extension.commands else []) extension.commands.extend([command] if command not in extension.commands else [])
# While genGroup() will call twice with aliased value, it does not provide all the information we need # While genGroup() will call twice with aliased value, it does not provide all the information we need
@ -220,30 +237,40 @@ class BaseGenerator(OutputGenerator):
for required in dict: for required in dict:
# group can be a Enum or Bitmask # group can be a Enum or Bitmask
for group in dict[required]: for group in dict[required]:
if group in self.vk.handles:
handle = self.vk.handles[group]
# Make sure list is unique
handle.extensions.extend([extension.name] if extension.name not in handle.extensions else [])
extension.handles[group].extend([handle] if handle not in extension.handles[group] else [])
if group in self.vk.enums: if group in self.vk.enums:
if group not in extension.enumFields: if group not in extension.enumFields:
extension.enumFields[group] = [] # Dict needs init extension.enumFields[group] = [] # Dict needs init
enum = self.vk.enums[group] enum = self.vk.enums[group]
# Need to convert all alias so they match what is in EnumField # Need to convert all alias so they match what is in EnumField
enumList = list(map(lambda x: x if x not in self.enumFieldAliasMap else self.enumFieldAliasMap[x], dict[required][group])) enumList = list(map(lambda x: x if x not in self.enumFieldAliasMap else self.dealias(x, self.enumFieldAliasMap), dict[required][group]))
for enumField in [x for x in enum.fields if x.name in enumList]: for enumField in [x for x in enum.fields if x.name in enumList]:
# Make sure list is unique # Make sure list is unique
enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else []) enum.fieldExtensions.extend([extension.name] if extension.name not in enum.fieldExtensions else [])
enumField.extensions.extend([extension] if extension not in enumField.extensions else []) enumField.extensions.extend([extension.name] if extension.name not in enumField.extensions else [])
extension.enumFields[group].extend([enumField] if enumField not in extension.enumFields[group] else []) extension.enumFields[group].extend([enumField] if enumField not in extension.enumFields[group] else [])
if group in self.vk.bitmasks: if group in self.vk.bitmasks:
if group not in extension.flags: if group not in extension.flagBits:
extension.flags[group] = [] # Dict needs init extension.flagBits[group] = [] # Dict needs init
bitmask = self.vk.bitmasks[group] bitmask = self.vk.bitmasks[group]
# Need to convert all alias so they match what is in Flags # Need to convert all alias so they match what is in Flags
flagList = list(map(lambda x: x if x not in self.flagAliasMap else self.flagAliasMap[x], dict[required][group])) flagList = list(map(lambda x: x if x not in self.flagAliasMap else self.dealias(x, self.flagAliasMap), dict[required][group]))
for flags in [x for x in bitmask.flags if x.name in flagList]: for flags in [x for x in bitmask.flags if x.name in flagList]:
# Make sure list is unique # Make sure list is unique
bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else []) bitmask.flagExtensions.extend([extension.name] if extension.name not in bitmask.flagExtensions else [])
flags.extensions.extend([extension] if extension not in flags.extensions else []) flags.extensions.extend([extension.name] if extension.name not in flags.extensions else [])
extension.flags[group].extend([flags] if flags not in extension.flags[group] else []) extension.flagBits[group].extend([flags] if flags not in extension.flagBits[group] else [])
if group in self.vk.flags:
flags = self.vk.flags[group]
# Make sure list is unique
flags.extensions.extend([extension.name] if extension.name not in flags.extensions else [])
extension.flags.extend([flags] if flags not in extension.flags[group] else [])
# Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions # Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions
# #
@ -259,17 +286,17 @@ class BaseGenerator(OutputGenerator):
for group in dict[required]: for group in dict[required]:
for enumName in dict[required][group]: for enumName in dict[required][group]:
isAlias = enumName in self.enumAliasMap isAlias = enumName in self.enumAliasMap
enumName = self.enumAliasMap[enumName] if isAlias else enumName enumName = self.dealias(enumName, self.enumAliasMap)
if enumName in self.vk.enums: if enumName in self.vk.enums:
enum = self.vk.enums[enumName] enum = self.vk.enums[enumName]
enum.extensions.extend([extension] if extension not in enum.extensions else []) enum.extensions.extend([extension.name] if extension.name not in enum.extensions else [])
extension.enums.extend([enum] if enum not in extension.enums else []) extension.enums.extend([enum] if enum not in extension.enums else [])
# Update fields with implicit base extension # Update fields with implicit base extension
if isAlias: if isAlias:
continue continue
enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else []) enum.fieldExtensions.extend([extension.name] if extension.name not in enum.fieldExtensions else [])
for enumField in [x for x in enum.fields if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]: for enumField in [x for x in enum.fields if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]:
enumField.extensions.extend([extension] if extension not in enumField.extensions else []) enumField.extensions.extend([extension.name] if extension.name not in enumField.extensions else [])
if enumName not in extension.enumFields: if enumName not in extension.enumFields:
extension.enumFields[enumName] = [] # Dict needs init extension.enumFields[enumName] = [] # Dict needs init
extension.enumFields[enumName].extend([enumField] if enumField not in extension.enumFields[enumName] else []) extension.enumFields[enumName].extend([enumField] if enumField not in extension.enumFields[enumName] else [])
@ -280,20 +307,20 @@ class BaseGenerator(OutputGenerator):
for bitmaskName in dict[required][group]: for bitmaskName in dict[required][group]:
bitmaskName = bitmaskName.replace('Flags', 'FlagBits') # Works since Flags is not repeated in name bitmaskName = bitmaskName.replace('Flags', 'FlagBits') # Works since Flags is not repeated in name
isAlias = bitmaskName in self.bitmaskAliasMap isAlias = bitmaskName in self.bitmaskAliasMap
bitmaskName = self.bitmaskAliasMap[bitmaskName] if isAlias else bitmaskName bitmaskName = self.dealias(bitmaskName, self.bitmaskAliasMap)
if bitmaskName in self.vk.bitmasks: if bitmaskName in self.vk.bitmasks:
bitmask = self.vk.bitmasks[bitmaskName] bitmask = self.vk.bitmasks[bitmaskName]
bitmask.extensions.extend([extension] if extension not in bitmask.extensions else []) bitmask.extensions.extend([extension.name] if extension.name not in bitmask.extensions else [])
extension.bitmasks.extend([bitmask] if bitmask not in extension.bitmasks else []) extension.bitmasks.extend([bitmask] if bitmask not in extension.bitmasks else [])
# Update flags with implicit base extension # Update flags with implicit base extension
if isAlias: if isAlias:
continue continue
bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else []) bitmask.flagExtensions.extend([extension.name] if extension.name not in bitmask.flagExtensions else [])
for flag in [x for x in bitmask.flags if (not x.extensions or (x.extensions and all(e in bitmask.extensions for e in x.extensions)))]: for flag in [x for x in bitmask.flags if (not x.extensions or (x.extensions and all(e in bitmask.extensions for e in x.extensions)))]:
flag.extensions.extend([extension] if extension not in flag.extensions else []) flag.extensions.extend([extension.name] if extension.name not in flag.extensions else [])
if bitmaskName not in extension.flags: if bitmaskName not in extension.flagBits:
extension.flags[bitmaskName] = [] # Dict needs init extension.flagBits[bitmaskName] = [] # Dict needs init
extension.flags[bitmaskName].extend([flag] if flag not in extension.flags[bitmaskName] else []) extension.flagBits[bitmaskName].extend([flag] if flag not in extension.flagBits[bitmaskName] else [])
# Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension # Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension
for extension in self.vk.extensions.values(): for extension in self.vk.extensions.values():
@ -302,34 +329,39 @@ class BaseGenerator(OutputGenerator):
for group in dict[required]: for group in dict[required]:
for structName in dict[required][group]: for structName in dict[required][group]:
isAlias = structName in self.structAliasMap isAlias = structName in self.structAliasMap
structName = self.structAliasMap[structName] if isAlias else structName structName = self.dealias(structName, self.structAliasMap)
# An EXT struct can alias a KHR struct,
# that in turns aliaes a core struct
# => Try to propagate aliasing, it can safely result in a no-op
isAlias = structName in self.structAliasMap
structName = self.structAliasMap[structName] if isAlias else structName
if structName in self.vk.structs: if structName in self.vk.structs:
struct = self.vk.structs[structName] struct = self.vk.structs[structName]
struct.extensions.extend([extension] if extension not in struct.extensions else []) struct.extensions.extend([extension.name] if extension.name not in struct.extensions else [])
# While we update struct alias inside other structs, the command itself might have the struct as a first level param. # While we update struct alias inside other structs, the command itself might have the struct as a first level param.
# We use this time to update params to have the promoted name # We use this time to update params to have the promoted name
# Example - https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/9322 # Example - https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/9322
# TODO: It is unclear why only structs need dealiasing here, but not other types, so this probably needs revisiting
for command in self.vk.commands.values(): for command in self.vk.commands.values():
for member in command.params: for member in command.params:
if member.type in self.structAliasMap: if member.type in self.structAliasMap:
member.type = self.structAliasMap[member.type] member.type = self.dealias(member.type, self.structAliasMap)
# Could build up a reverse lookup map, but since these are not too large of list, just do here # Could build up a reverse lookup map, but since these are not too large of list, just do here
# (Need to be done after we have found all the aliases) # (Need to be done after we have found all the aliases)
for key, value in self.structAliasMap.items(): for key, value in self.structAliasMap.items():
self.vk.structs[value].aliases.append(key) self.vk.structs[self.dealias(value, self.structAliasMap)].aliases.append(key)
for key, value in self.enumFieldAliasMap.items():
self.enumFieldMap[self.dealias(value, self.enumFieldAliasMap)].aliases.append(key)
for key, value in self.enumAliasMap.items(): for key, value in self.enumAliasMap.items():
self.vk.enums[value].aliases.append(key) self.vk.enums[self.dealias(value, self.enumAliasMap)].aliases.append(key)
for key, value in self.flagAliasMap.items():
self.flagMap[self.dealias(value, self.flagAliasMap)].aliases.append(key)
for key, value in self.bitmaskAliasMap.items(): for key, value in self.bitmaskAliasMap.items():
self.vk.bitmasks[value].aliases.append(key) self.vk.bitmasks[self.dealias(value, self.bitmaskAliasMap)].aliases.append(key)
for key, value in self.flagsAliasMap.items():
self.vk.flags[self.dealias(value, self.flagsAliasMap)].aliases.append(key)
for key, value in self.handleAliasMap.items(): for key, value in self.handleAliasMap.items():
self.vk.handles[value].aliases.append(key) self.vk.handles[self.dealias(value, self.handleAliasMap)].aliases.append(key)
def endFile(self): def endFile(self):
# This is the point were reg.py has ran, everything is collected # This is the point were reg.py has ran, everything is collected
@ -342,15 +374,19 @@ class BaseGenerator(OutputGenerator):
enum.returnedOnly = False enum.returnedOnly = False
for bitmask in [self.vk.bitmasks[x.type] for x in struct.members if x.type in self.vk.bitmasks]: for bitmask in [self.vk.bitmasks[x.type] for x in struct.members if x.type in self.vk.bitmasks]:
bitmask.returnedOnly = False bitmask.returnedOnly = False
for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in struct.members if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]: for flags in [self.vk.flags[x.type] for x in struct.members if x.type in self.vk.flags]:
bitmask.returnedOnly = False flags.returnedOnly = False
if flags.bitmaskName is not None:
self.vk.bitmasks[flags.bitmaskName].returnedOnly = False
for command in self.vk.commands.values(): for command in self.vk.commands.values():
for enum in [self.vk.enums[x.type] for x in command.params if x.type in self.vk.enums]: for enum in [self.vk.enums[x.type] for x in command.params if x.type in self.vk.enums]:
enum.returnedOnly = False enum.returnedOnly = False
for bitmask in [self.vk.bitmasks[x.type] for x in command.params if x.type in self.vk.bitmasks]: for bitmask in [self.vk.bitmasks[x.type] for x in command.params if x.type in self.vk.bitmasks]:
bitmask.returnedOnly = False bitmask.returnedOnly = False
for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in command.params if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]: for flags in [self.vk.flags[x.type] for x in command.params if x.type in self.vk.flags]:
bitmask.returnedOnly = False flags.returnedOnly = False
if flags.bitmaskName is not None:
self.vk.bitmasks[flags.bitmaskName].returnedOnly = False
# Turn handle parents into pointers to classes # Turn handle parents into pointers to classes
for handle in [x for x in self.vk.handles.values() if x.parent is not None]: for handle in [x for x in self.vk.handles.values() if x.parent is not None]:
@ -546,7 +582,8 @@ class BaseGenerator(OutputGenerator):
# Some values have multiple extensions (ex VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR) # Some values have multiple extensions (ex VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
# genGroup() lists them twice # genGroup() lists them twice
if next((x for x in fields if x.name == fieldName), None) is None: if next((x for x in fields if x.name == fieldName), None) is None:
fields.append(EnumField(fieldName, protect, negative, valueInt, valueStr, [])) self.enumFieldMap[fieldName] = EnumField(fieldName, [], protect, negative, valueInt, valueStr, [])
fields.append(self.enumFieldMap[fieldName])
self.vk.enums[groupName] = Enum(groupName, [], groupProtect, bitwidth, True, fields, [], []) self.vk.enums[groupName] = Enum(groupName, [], groupProtect, bitwidth, True, fields, [], [])
@ -574,7 +611,8 @@ class BaseGenerator(OutputGenerator):
# Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT) # Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
# genGroup() lists them twice # genGroup() lists them twice
if next((x for x in fields if x.name == flagName), None) is None: if next((x for x in fields if x.name == flagName), None) is None:
fields.append(Flag(flagName, protect, valueInt, valueStr, flagMultiBit, flagZero, [])) self.flagMap[flagName] = Flag(flagName, [], protect, valueInt, valueStr, flagMultiBit, flagZero, [])
fields.append(self.flagMap[flagName])
flagName = groupName.replace('FlagBits', 'Flags') flagName = groupName.replace('FlagBits', 'Flags')
self.vk.bitmasks[groupName] = Bitmask(groupName, [], flagName, groupProtect, bitwidth, True, fields, [], []) self.vk.bitmasks[groupName] = Bitmask(groupName, [], flagName, groupProtect, bitwidth, True, fields, [], [])
@ -583,9 +621,9 @@ class BaseGenerator(OutputGenerator):
OutputGenerator.genType(self, typeInfo, typeName, alias) OutputGenerator.genType(self, typeInfo, typeName, alias)
typeElem = typeInfo.elem typeElem = typeInfo.elem
protect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None protect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
extension = [self.currentExtension] if self.currentExtension is not None else []
category = typeElem.get('category') category = typeElem.get('category')
if (category == 'struct' or category == 'union'): if (category == 'struct' or category == 'union'):
extension = [self.currentExtension] if self.currentExtension is not None else []
if alias is not None: if alias is not None:
self.structAliasMap[typeName] = alias self.structAliasMap[typeName] = alias
return return
@ -662,15 +700,32 @@ class BaseGenerator(OutputGenerator):
dispatchable = typeElem.find('type').text == 'VK_DEFINE_HANDLE' dispatchable = typeElem.find('type').text == 'VK_DEFINE_HANDLE'
self.vk.handles[typeName] = Handle(typeName, [], type, protect, parent, instance, device, dispatchable) self.vk.handles[typeName] = Handle(typeName, [], type, protect, parent, instance, device, dispatchable, extension)
elif category == 'define': elif category == 'define':
if typeName == 'VK_HEADER_VERSION': if typeName == 'VK_HEADER_VERSION':
self.vk.headerVersion = typeElem.find('name').tail.strip() self.vk.headerVersion = typeElem.find('name').tail.strip()
elif category == 'bitmask':
if alias is not None:
self.flagsAliasMap[typeName] = alias
return
# Bitmask types, i.e. flags
baseFlagsType = typeElem.find('type').text
bitWidth = 64 if baseFlagsType == 'VkFlags64' else 32
# Bitmask enum type is either in the 'requires' or 'bitvalues' attribute
# (for some reason there are two conventions)
bitmaskName = typeElem.get('bitvalues')
if bitmaskName is None:
bitmaskName = typeElem.get('requires')
self.vk.flags[typeName] = Flags(typeName, [], bitmaskName, protect, baseFlagsType, bitWidth, True, extension)
else: else:
# not all categories are used # not all categories are used
# 'group'/'enum'/'bitmask' are routed to genGroup instead # 'group'/'enum' are routed to genGroup instead
# 'basetype'/'include' are only for headers # 'basetype'/'include' are only for headers
# 'funcpointer` ignore until needed # 'funcpointer` ignore until needed
return return

250
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

104
registry/vk.xml
View file

@ -179,7 +179,7 @@ branch of the member gitlab server.
#define <name>VKSC_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0</type> #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 <type api="vulkan" category="define">// Version of this file
#define <name>VK_HEADER_VERSION</name> 315</type> #define <name>VK_HEADER_VERSION</name> 316</type>
<type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file <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> #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 <type api="vulkansc" category="define">// Version of this file
@ -10291,6 +10291,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="noauto"><type>uint32_t</type> <name>maxExternalQueues</name></member> <member limittype="noauto"><type>uint32_t</type> <name>maxExternalQueues</name></member>
</type> </type>
<type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV"><type>VK_DEFINE_HANDLE</type>(<name>VkExternalComputeQueueNV</name>)</type> <type category="handle" parent="VkDevice" objtypeenum="VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV"><type>VK_DEFINE_HANDLE</type>(<name>VkExternalComputeQueueNV</name>)</type>
<type category="struct" name="VkPhysicalDeviceFormatPackFeaturesARM" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>formatPack</name></member>
</type>
</types> </types>
@ -16824,6 +16829,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command queues="compute" renderpass="inside" cmdbufferlevel="primary,secondary" tasks="action"> <command queues="compute" renderpass="inside" cmdbufferlevel="primary,secondary" tasks="action">
<proto><type>void</type> <name>vkCmdDispatchTileQCOM</name></proto> <proto><type>void</type> <name>vkCmdDispatchTileQCOM</name></proto>
<param><type>VkCommandBuffer</type> <name>commandBuffer</name></param> <param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
<param>const <type>VkDispatchTileInfoQCOM</type>* <name>pDispatchTileInfo</name></param>
</command> </command>
<command queues="graphics,compute" renderpass="inside" cmdbufferlevel="primary,secondary" tasks="state"> <command queues="graphics,compute" renderpass="inside" cmdbufferlevel="primary,secondary" tasks="state">
<proto><type>void</type> <name>vkCmdBeginPerTileExecutionQCOM</name></proto> <proto><type>void</type> <name>vkCmdBeginPerTileExecutionQCOM</name></proto>
@ -27414,10 +27420,27 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="vertexAttributeRobustness" struct="VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"/> <feature name="vertexAttributeRobustness" struct="VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"/>
</require> </require>
</extension> </extension>
<extension name="VK_ARM_extension_610" number="610" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled"> <extension name="VK_ARM_format_pack" number="610" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan">
<require> <require>
<enum value="0" name="VK_ARM_EXTENSION_610_SPEC_VERSION"/> <enum value="1" name="VK_ARM_FORMAT_PACK_SPEC_VERSION"/>
<enum value="&quot;VK_ARM_extension_610&quot;" name="VK_ARM_EXTENSION_610_EXTENSION_NAME"/> <enum value="&quot;VK_ARM_format_pack&quot;" name="VK_ARM_FORMAT_PACK_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM"/>
<type name="VkPhysicalDeviceFormatPackFeaturesARM"/>
<feature name="formatPack" struct="VkPhysicalDeviceFormatPackFeaturesARM"/>
<enum offset="0" extends="VkFormat" name="VK_FORMAT_R10X6_UINT_PACK16_ARM"/>
<enum offset="1" extends="VkFormat" name="VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM"/>
<enum offset="2" extends="VkFormat" name="VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM"/>
<enum offset="3" extends="VkFormat" name="VK_FORMAT_R12X4_UINT_PACK16_ARM"/>
<enum offset="4" extends="VkFormat" name="VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM"/>
<enum offset="5" extends="VkFormat" name="VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM"/>
<enum offset="6" extends="VkFormat" name="VK_FORMAT_R14X2_UINT_PACK16_ARM"/>
<enum offset="7" extends="VkFormat" name="VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM"/>
<enum offset="8" extends="VkFormat" name="VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM"/>
<enum offset="9" extends="VkFormat" name="VK_FORMAT_R14X2_UNORM_PACK16_ARM"/>
<enum offset="10" extends="VkFormat" name="VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM"/>
<enum offset="11" extends="VkFormat" name="VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM"/>
<enum offset="12" extends="VkFormat" name="VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM"/>
<enum offset="13" extends="VkFormat" name="VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM"/>
</require> </require>
</extension> </extension>
<extension name="VK_NV_extension_611" number="611" author="NV" contact="David Kvasnica @DaKvasNV" supported="disabled"> <extension name="VK_NV_extension_611" number="611" author="NV" contact="David Kvasnica @DaKvasNV" supported="disabled">
@ -27473,6 +27496,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<require> <require>
<enum value="0" name="VK_EXT_EXTENSION_617_SPEC_VERSION"/> <enum value="0" name="VK_EXT_EXTENSION_617_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_617&quot;" name="VK_EXT_EXTENSION_617_EXTENSION_NAME"/> <enum value="&quot;VK_EXT_extension_617&quot;" name="VK_EXT_EXTENSION_617_EXTENSION_NAME"/>
<enum bitpos="5" extends="VkSwapchainCreateFlagBitsKHR" name="VK_SWAPCHAIN_CREATE_RESERVED_5_BIT_EXT"/>
</require> </require>
</extension> </extension>
<extension name="VK_EXT_extension_618" number="618" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled"> <extension name="VK_EXT_extension_618" number="618" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
@ -27577,6 +27601,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_630&quot;" name="VK_EXT_EXTENSION_630_EXTENSION_NAME"/> <enum value="&quot;VK_EXT_extension_630&quot;" name="VK_EXT_EXTENSION_630_EXTENSION_NAME"/>
</require> </require>
</extension> </extension>
<extension name="VK_KHR_extension_631" number="631" author="KHR" contact="Mike Blumenkrantz @zmike" supported="disabled">
<require>
<enum value="0" name="VK_KHR_EXTENSION_631_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_extension_631&quot;" name="VK_KHR_EXTENSION_631_EXTENSION_NAME"/>
</require>
</extension>
</extensions> </extensions>
<formats> <formats>
<format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8"> <format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">
@ -28958,6 +28988,72 @@ typedef void* <name>MTLSharedEvent_id</name>;
<component name="R" bits="16" numericFormat="SFIXED5"/> <component name="R" bits="16" numericFormat="SFIXED5"/>
<component name="G" bits="16" numericFormat="SFIXED5"/> <component name="G" bits="16" numericFormat="SFIXED5"/>
</format> </format>
<format name="VK_FORMAT_R10X6_UINT_PACK16_ARM" class="16-bit" blockSize="2" texelsPerBlock="1" packed="16">
<component name="R" bits="10" numericFormat="UINT"/>
</format>
<format name="VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM" class="32-bit" blockSize="4" texelsPerBlock="1" packed="16">
<component name="R" bits="10" numericFormat="UINT"/>
<component name="G" bits="10" numericFormat="UINT"/>
</format>
<format name="VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM" class="64-bit R10G10B10A10" blockSize="8" texelsPerBlock="1" packed="16">
<component name="R" bits="10" numericFormat="UINT"/>
<component name="G" bits="10" numericFormat="UINT"/>
<component name="B" bits="10" numericFormat="UINT"/>
<component name="A" bits="10" numericFormat="UINT"/>
</format>
<format name="VK_FORMAT_R12X4_UINT_PACK16_ARM" class="16-bit" blockSize="2" texelsPerBlock="1" packed="16">
<component name="R" bits="12" numericFormat="UINT"/>
</format>
<format name="VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM" class="32-bit" blockSize="4" texelsPerBlock="1" packed="16">
<component name="R" bits="12" numericFormat="UINT"/>
<component name="G" bits="12" numericFormat="UINT"/>
</format>
<format name="VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM" class="64-bit R12G12B12A12" blockSize="8" texelsPerBlock="1" packed="16">
<component name="R" bits="12" numericFormat="UINT"/>
<component name="G" bits="12" numericFormat="UINT"/>
<component name="B" bits="12" numericFormat="UINT"/>
<component name="A" bits="12" numericFormat="UINT"/>
</format>
<format name="VK_FORMAT_R14X2_UINT_PACK16_ARM" class="16-bit" blockSize="2" texelsPerBlock="1" packed="16">
<component name="R" bits="14" numericFormat="UINT"/>
</format>
<format name="VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM" class="32-bit" blockSize="4" texelsPerBlock="1" packed="16">
<component name="R" bits="14" numericFormat="UINT"/>
<component name="G" bits="14" numericFormat="UINT"/>
</format>
<format name="VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM" class="64-bit R14G14B14A14" blockSize="8" texelsPerBlock="1" packed="16">
<component name="R" bits="14" numericFormat="UINT"/>
<component name="G" bits="14" numericFormat="UINT"/>
<component name="B" bits="14" numericFormat="UINT"/>
<component name="A" bits="14" numericFormat="UINT"/>
</format>
<format name="VK_FORMAT_R14X2_UNORM_PACK16_ARM" class="16-bit" blockSize="2" texelsPerBlock="1" packed="16">
<component name="R" bits="14" numericFormat="UNORM"/>
</format>
<format name="VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM" class="32-bit" blockSize="4" texelsPerBlock="1" packed="16">
<component name="R" bits="14" numericFormat="UNORM"/>
<component name="G" bits="14" numericFormat="UNORM"/>
</format>
<format name="VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM" class="64-bit R14G14B14A14" blockSize="8" texelsPerBlock="1" packed="16">
<component name="R" bits="14" numericFormat="UNORM"/>
<component name="G" bits="14" numericFormat="UNORM"/>
<component name="B" bits="14" numericFormat="UNORM"/>
<component name="A" bits="14" numericFormat="UNORM"/>
</format>
<format name="VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM" class="14-bit 2-plane 420" blockSize="6" texelsPerBlock="1" packed="16" chroma="420">
<component name="G" bits="14" numericFormat="UNORM" planeIndex="0"/>
<component name="B" bits="14" numericFormat="UNORM" planeIndex="1"/>
<component name="R" bits="14" numericFormat="UNORM" planeIndex="1"/>
<plane index="0" widthDivisor="1" heightDivisor="1" compatible="VK_FORMAT_R14X2_UNORM_PACK16_ARM"/>
<plane index="1" widthDivisor="2" heightDivisor="2" compatible="VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM"/>
</format>
<format name="VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM" class="14-bit 2-plane 422" blockSize="6" texelsPerBlock="1" packed="16" chroma="422">
<component name="G" bits="14" numericFormat="UNORM" planeIndex="0"/>
<component name="B" bits="14" numericFormat="UNORM" planeIndex="1"/>
<component name="R" bits="14" numericFormat="UNORM" planeIndex="1"/>
<plane index="0" widthDivisor="1" heightDivisor="1" compatible="VK_FORMAT_R14X2_UNORM_PACK16_ARM"/>
<plane index="1" widthDivisor="2" heightDivisor="1" compatible="VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM"/>
</format>
</formats> </formats>
<spirvextensions comment="SPIR-V Extensions allowed in Vulkan and what is required to use it"> <spirvextensions comment="SPIR-V Extensions allowed in Vulkan and what is required to use it">
<spirvextension name="SPV_KHR_variable_pointers"> <spirvextension name="SPV_KHR_variable_pointers">

50
registry/vulkan_object.py
View file

@ -29,14 +29,17 @@ class Extension:
specialUse: list[str] specialUse: list[str]
# These are here to allow for easy reverse lookups # These are here to allow for easy reverse lookups
# To prevent infinite recursion, other classes reference a string back to the Extension class
# Quotes allow us to forward declare the dataclass # Quotes allow us to forward declare the dataclass
handles: list['Handle'] = field(default_factory=list, init=False)
commands: list['Command'] = field(default_factory=list, init=False) commands: list['Command'] = field(default_factory=list, init=False)
enums: list['Enum'] = field(default_factory=list, init=False) enums: list['Enum'] = field(default_factory=list, init=False)
bitmasks: list['Bitmask'] = field(default_factory=list, init=False) bitmasks: list['Bitmask'] = field(default_factory=list, init=False)
flags: dict[str, list['Flags']] = field(default_factory=dict, init=False)
# Use the Enum name to see what fields are extended # Use the Enum name to see what fields are extended
enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False) enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False)
# Use the Bitmaks name to see what flags are extended # Use the Bitmask name to see what flag bits are added to it
flags: dict[str, list['Flag']] = field(default_factory=dict, init=False) flagBits: dict[str, list['Flag']] = field(default_factory=dict, init=False)
@dataclass @dataclass
class Version: class Version:
@ -65,6 +68,8 @@ class Handle:
dispatchable: bool dispatchable: bool
extensions: list[str] # All extensions that enable the handle
def __lt__(self, other): def __lt__(self, other):
return self.name < other.name return self.name < other.name
@ -133,7 +138,7 @@ class Command:
alias: (str | None) # Because commands are interfaces into layers/drivers, we need all command alias alias: (str | None) # Because commands are interfaces into layers/drivers, we need all command alias
protect: (str | None) # ex) 'VK_ENABLE_BETA_EXTENSIONS' protect: (str | None) # ex) 'VK_ENABLE_BETA_EXTENSIONS'
extensions: list[Extension] # All extensions that enable the struct extensions: list[str] # All extensions that enable the struct
version: (Version | None) # None if Version 1.0 version: (Version | None) # None if Version 1.0
returnType: str # ex) void, VkResult, etc returnType: str # ex) void, VkResult, etc
@ -219,7 +224,7 @@ class Struct:
name: str # ex) VkImageSubresource2 name: str # ex) VkImageSubresource2
aliases: list[str] # ex) ['VkImageSubresource2KHR', 'VkImageSubresource2EXT'] aliases: list[str] # ex) ['VkImageSubresource2KHR', 'VkImageSubresource2EXT']
extensions: list[Extension] # All extensions that enable the struct extensions: list[str] # All extensions that enable the struct
version: (Version | None) # None if Version 1.0 version: (Version | None) # None if Version 1.0
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
@ -242,7 +247,9 @@ class Struct:
@dataclass @dataclass
class EnumField: class EnumField:
"""<enum> of type enum""" """<enum> of type enum"""
name: str # ex) VK_DYNAMIC_STATE_SCISSOR name: str # ex) VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT
aliases: list[str] # ex) ['VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT']
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
negative: bool # True if negative values are allowed (ex. VkResult) negative: bool # True if negative values are allowed (ex. VkResult)
@ -250,7 +257,7 @@ class EnumField:
valueStr: str # value as shown in spec (ex. "0", "2", "1000267000", "0x00000004") valueStr: str # value as shown in spec (ex. "0", "2", "1000267000", "0x00000004")
# some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR) # some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
extensions: list[Extension] # None if part of 1.0 core extensions: list[str] # None if part of 1.0 core
def __lt__(self, other): def __lt__(self, other):
return self.name < other.name return self.name < other.name
@ -268,9 +275,9 @@ class Enum:
fields: list[EnumField] fields: list[EnumField]
extensions: list[Extension] # None if part of 1.0 core extensions: list[str] # None if part of 1.0 core
# Unique list of all extension that are involved in 'fields' (superset of 'extensions') # Unique list of all extension that are involved in 'fields' (superset of 'extensions')
fieldExtensions: list[Extension] fieldExtensions: list[str]
def __lt__(self, other): def __lt__(self, other):
return self.name < other.name return self.name < other.name
@ -279,6 +286,8 @@ class Enum:
class Flag: class Flag:
"""<enum> of type bitmask""" """<enum> of type bitmask"""
name: str # ex) VK_ACCESS_2_SHADER_READ_BIT name: str # ex) VK_ACCESS_2_SHADER_READ_BIT
aliases: str # ex) ['VK_ACCESS_2_SHADER_READ_BIT_KHR']
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
value: int value: int
@ -287,7 +296,7 @@ class Flag:
zero: bool # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE) zero: bool # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE)
# some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT) # some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
extensions: list[Extension] # None if part of 1.0 core extensions: list[str] # None if part of 1.0 core
def __lt__(self, other): def __lt__(self, other):
return self.name < other.name return self.name < other.name
@ -306,9 +315,27 @@ class Bitmask:
flags: list[Flag] flags: list[Flag]
extensions: list[Extension] # None if part of 1.0 core extensions: list[str] # None if part of 1.0 core
# Unique list of all extension that are involved in 'flag' (superset of 'extensions') # Unique list of all extension that are involved in 'flag' (superset of 'extensions')
flagExtensions: list[Extension] flagExtensions: list[str]
def __lt__(self, other):
return self.name < other.name
@dataclass
class Flags:
"""<type> defining flags types"""
name: str # ex) VkAccessFlags2
aliases: list[str] # ex) [`VkAccessFlags2KHR`]
bitmaskName: (str | None) # ex) VkAccessFlagBits2
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
baseFlagsType: str # ex) VkFlags
bitWidth: int # 32 or 64
returnedOnly: bool
extensions: list[str] # None if part of 1.0 core
def __lt__(self, other): def __lt__(self, other):
return self.name < other.name return self.name < other.name
@ -422,6 +449,7 @@ class VulkanObject():
structs: dict[str, Struct] = field(default_factory=dict, init=False) structs: dict[str, Struct] = field(default_factory=dict, init=False)
enums: dict[str, Enum] = field(default_factory=dict, init=False) enums: dict[str, Enum] = field(default_factory=dict, init=False)
bitmasks: dict[str, Bitmask] = field(default_factory=dict, init=False) bitmasks: dict[str, Bitmask] = field(default_factory=dict, init=False)
flags: dict[str, Flags] = field(default_factory=dict, init=False)
formats: dict[str, Format] = field(default_factory=dict, init=False) formats: dict[str, Format] = field(default_factory=dict, init=False)
syncStage: list[SyncStage] = field(default_factory=list, init=False) syncStage: list[SyncStage] = field(default_factory=list, init=False)