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

7545
include/vulkan/vulkan.cppm
View file

File diff suppressed because it is too large Load diff

29472
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
// 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.
#define VK_NV_displacement_micromap 1
#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
// Version of this file
#define VK_HEADER_VERSION 315
#define VK_HEADER_VERSION 316
// Complete version of this file
#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_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_FORMAT_PACK_FEATURES_ARM = 1000609000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001,
#ifdef VK_ENABLE_BETA_EXTENSIONS
@ -1898,6 +1899,20 @@ typedef enum VkFormat {
VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
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_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_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"
// 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.
#define VK_QCOM_tile_shading 1
#define VK_QCOM_TILE_SHADING_SPEC_VERSION 1
@ -17274,13 +17197,14 @@ typedef struct VkDispatchTileInfoQCOM {
const void* pNext;
} 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_vkCmdEndPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM(
VkCommandBuffer commandBuffer);
VkCommandBuffer commandBuffer,
const VkDispatchTileInfoQCOM* pDispatchTileInfo);
VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM(
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.
#define VK_NV_present_metering 1
#define VK_NV_PRESENT_METERING_SPEC_VERSION 1

12981
include/vulkan/vulkan_enums.hpp
View file

File diff suppressed because it is too large Load diff

4787
include/vulkan/vulkan_extension_inspection.hpp
View file

File diff suppressed because it is too large Load diff

5117
include/vulkan/vulkan_format_traits.hpp
View file

File diff suppressed because one or more lines are too long

28448
include/vulkan/vulkan_funcs.hpp
View file

File diff suppressed because it is too large Load diff

14649
include/vulkan/vulkan_handles.hpp
View file

File diff suppressed because it is too large Load diff

19676
include/vulkan/vulkan_hash.hpp
View file

File diff suppressed because it is too large Load diff

17
include/vulkan/vulkan_hpp_macros.hpp
View file

@ -1,10 +1,11 @@
// Copyright 2015-2025 The Khronos Group Inc.
//
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//
// This header is generated from the Khronos Vulkan XML API Registry.
#ifndef VULKAN_HPP_MACROS_HPP
#define VULKAN_HPP_MACROS_HPP
@ -92,12 +93,11 @@
#endif
#ifndef VK_USE_64_BIT_PTR_DEFINES
# 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 )
# define VK_USE_64_BIT_PTR_DEFINES 1
# else
# define VK_USE_64_BIT_PTR_DEFINES 0
# endif
#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)
#define VK_USE_64_BIT_PTR_DEFINES 1
#else
#define VK_USE_64_BIT_PTR_DEFINES 0
#endif
#endif
// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
@ -259,7 +259,7 @@ namespace VULKAN_HPP_NAMESPACE
{
namespace detail
{
class DispatchLoaderDynamic;
class DispatchLoaderDynamic;
#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
@ -323,4 +323,5 @@ namespace VULKAN_HPP_NAMESPACE
# define VULKAN_HPP_RAII_CREATE_NOEXCEPT
#endif
#endif

48674
include/vulkan/vulkan_raii.hpp
View file

File diff suppressed because it is too large Load diff

1233
include/vulkan/vulkan_shared.hpp
View file

File diff suppressed because it is too large Load diff

9247
include/vulkan/vulkan_static_assertions.hpp
View file

File diff suppressed because it is too large Load diff

103166
include/vulkan/vulkan_structs.hpp
View file

File diff suppressed because one or more lines are too long

10138
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
from vulkan_object import (VulkanObject,
Extension, Version, Handle, Param, Queues, CommandScope, Command,
EnumField, Enum, Flag, Bitmask, Member, Struct,
EnumField, Enum, Flag, Bitmask, Flags, Member, Struct,
FormatComponent, FormatPlane, Format,
SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline,
SpirvEnables, Spirv)
@ -146,9 +146,26 @@ class BaseGenerator(OutputGenerator):
self.enumFieldAliasMap = dict()
self.bitmaskAliasMap = dict()
self.flagAliasMap = dict()
self.flagsAliasMap = dict()
self.structAliasMap = 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):
# Prevents having to check before writing
if data is not None and data != "":
@ -212,7 +229,7 @@ class BaseGenerator(OutputGenerator):
command = self.vk.commands[commandName]
# 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 [])
# 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:
# group can be a Enum or Bitmask
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 not in extension.enumFields:
extension.enumFields[group] = [] # Dict needs init
enum = self.vk.enums[group]
# 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]:
# Make sure list is unique
enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
enum.fieldExtensions.extend([extension.name] if extension.name not in enum.fieldExtensions 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 [])
if group in self.vk.bitmasks:
if group not in extension.flags:
extension.flags[group] = [] # Dict needs init
if group not in extension.flagBits:
extension.flagBits[group] = [] # Dict needs init
bitmask = self.vk.bitmasks[group]
# 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]:
# Make sure list is unique
bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else [])
flags.extensions.extend([extension] if extension not in flags.extensions else [])
extension.flags[group].extend([flags] if flags not in extension.flags[group] else [])
bitmask.flagExtensions.extend([extension.name] if extension.name not in bitmask.flagExtensions else [])
flags.extensions.extend([extension.name] if extension.name not in flags.extensions 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
#
@ -259,17 +286,17 @@ class BaseGenerator(OutputGenerator):
for group in dict[required]:
for enumName in dict[required][group]:
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:
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 [])
# Update fields with implicit base extension
if isAlias:
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)))]:
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:
extension.enumFields[enumName] = [] # Dict needs init
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]:
bitmaskName = bitmaskName.replace('Flags', 'FlagBits') # Works since Flags is not repeated in name
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:
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 [])
# Update flags with implicit base extension
if isAlias:
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)))]:
flag.extensions.extend([extension] if extension not in flag.extensions else [])
if bitmaskName not in extension.flags:
extension.flags[bitmaskName] = [] # Dict needs init
extension.flags[bitmaskName].extend([flag] if flag not in extension.flags[bitmaskName] else [])
flag.extensions.extend([extension.name] if extension.name not in flag.extensions else [])
if bitmaskName not in extension.flagBits:
extension.flagBits[bitmaskName] = [] # Dict needs init
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
for extension in self.vk.extensions.values():
@ -302,34 +329,39 @@ class BaseGenerator(OutputGenerator):
for group in dict[required]:
for structName in dict[required][group]:
isAlias = structName in self.structAliasMap
structName = self.structAliasMap[structName] if isAlias else structName
# 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
structName = self.dealias(structName, self.structAliasMap)
if structName in self.vk.structs:
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.
# We use this time to update params to have the promoted name
# 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 member in command.params:
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
# (Need to be done after we have found all the aliases)
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():
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():
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():
self.vk.handles[value].aliases.append(key)
self.vk.handles[self.dealias(value, self.handleAliasMap)].aliases.append(key)
def endFile(self):
# This is the point were reg.py has ran, everything is collected
@ -342,15 +374,19 @@ class BaseGenerator(OutputGenerator):
enum.returnedOnly = False
for bitmask in [self.vk.bitmasks[x.type] for x in struct.members if x.type in self.vk.bitmasks]:
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]:
bitmask.returnedOnly = False
for flags in [self.vk.flags[x.type] for x in struct.members if x.type in self.vk.flags]:
flags.returnedOnly = False
if flags.bitmaskName is not None:
self.vk.bitmasks[flags.bitmaskName].returnedOnly = False
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]:
enum.returnedOnly = False
for bitmask in [self.vk.bitmasks[x.type] for x in command.params if x.type in self.vk.bitmasks]:
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]:
bitmask.returnedOnly = False
for flags in [self.vk.flags[x.type] for x in command.params if x.type in self.vk.flags]:
flags.returnedOnly = False
if flags.bitmaskName is not None:
self.vk.bitmasks[flags.bitmaskName].returnedOnly = False
# Turn handle parents into pointers to classes
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)
# genGroup() lists them twice
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, [], [])
@ -574,7 +611,8 @@ class BaseGenerator(OutputGenerator):
# Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
# genGroup() lists them twice
if next((x for x in fields if x.name == flagName), None) is None:
fields.append(Flag(flagName, protect, valueInt, valueStr, flagMultiBit, flagZero, []))
self.flagMap[flagName] = Flag(flagName, [], protect, valueInt, valueStr, flagMultiBit, flagZero, [])
fields.append(self.flagMap[flagName])
flagName = groupName.replace('FlagBits', 'Flags')
self.vk.bitmasks[groupName] = Bitmask(groupName, [], flagName, groupProtect, bitwidth, True, fields, [], [])
@ -583,9 +621,9 @@ class BaseGenerator(OutputGenerator):
OutputGenerator.genType(self, typeInfo, typeName, alias)
typeElem = typeInfo.elem
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')
if (category == 'struct' or category == 'union'):
extension = [self.currentExtension] if self.currentExtension is not None else []
if alias is not None:
self.structAliasMap[typeName] = alias
return
@ -662,15 +700,32 @@ class BaseGenerator(OutputGenerator):
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':
if typeName == 'VK_HEADER_VERSION':
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:
# 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
# 'funcpointer` ignore until needed
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>
<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
#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
@ -10291,6 +10291,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="noauto"><type>uint32_t</type> <name>maxExternalQueues</name></member>
</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>
@ -16824,6 +16829,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command queues="compute" renderpass="inside" cmdbufferlevel="primary,secondary" tasks="action">
<proto><type>void</type> <name>vkCmdDispatchTileQCOM</name></proto>
<param><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
<param>const <type>VkDispatchTileInfoQCOM</type>* <name>pDispatchTileInfo</name></param>
</command>
<command queues="graphics,compute" renderpass="inside" cmdbufferlevel="primary,secondary" tasks="state">
<proto><type>void</type> <name>vkCmdBeginPerTileExecutionQCOM</name></proto>
@ -27414,10 +27420,27 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="vertexAttributeRobustness" struct="VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT"/>
</require>
</extension>
<extension name="VK_ARM_extension_610" number="610" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="disabled">
<extension name="VK_ARM_format_pack" number="610" type="device" author="ARM" contact="Jan-Harald Fredriksen @janharaldfredriksen-arm" supported="vulkan">
<require>
<enum value="0" name="VK_ARM_EXTENSION_610_SPEC_VERSION"/>
<enum value="&quot;VK_ARM_extension_610&quot;" name="VK_ARM_EXTENSION_610_EXTENSION_NAME"/>
<enum value="1" name="VK_ARM_FORMAT_PACK_SPEC_VERSION"/>
<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>
</extension>
<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>
<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 bitpos="5" extends="VkSwapchainCreateFlagBitsKHR" name="VK_SWAPCHAIN_CREATE_RESERVED_5_BIT_EXT"/>
</require>
</extension>
<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"/>
</require>
</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>
<formats>
<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="G" bits="16" numericFormat="SFIXED5"/>
</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>
<spirvextensions comment="SPIR-V Extensions allowed in Vulkan and what is required to use it">
<spirvextension name="SPV_KHR_variable_pointers">

50
registry/vulkan_object.py
View file

@ -29,14 +29,17 @@ class Extension:
specialUse: list[str]
# 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
handles: list['Handle'] = field(default_factory=list, init=False)
commands: list['Command'] = field(default_factory=list, init=False)
enums: list['Enum'] = 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
enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False)
# Use the Bitmaks name to see what flags are extended
flags: dict[str, list['Flag']] = field(default_factory=dict, init=False)
# Use the Bitmask name to see what flag bits are added to it
flagBits: dict[str, list['Flag']] = field(default_factory=dict, init=False)
@dataclass
class Version:
@ -65,6 +68,8 @@ class Handle:
dispatchable: bool
extensions: list[str] # All extensions that enable the handle
def __lt__(self, other):
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
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
returnType: str # ex) void, VkResult, etc
@ -219,7 +224,7 @@ class Struct:
name: str # ex) VkImageSubresource2
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
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
@ -242,7 +247,9 @@ class Struct:
@dataclass
class EnumField:
"""<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
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")
# 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):
return self.name < other.name
@ -268,9 +275,9 @@ class Enum:
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')
fieldExtensions: list[Extension]
fieldExtensions: list[str]
def __lt__(self, other):
return self.name < other.name
@ -279,6 +286,8 @@ class Enum:
class Flag:
"""<enum> of type bitmask"""
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
value: int
@ -287,7 +296,7 @@ class Flag:
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)
extensions: list[Extension] # None if part of 1.0 core
extensions: list[str] # None if part of 1.0 core
def __lt__(self, other):
return self.name < other.name
@ -306,9 +315,27 @@ class Bitmask:
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')
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):
return self.name < other.name
@ -422,6 +449,7 @@ class VulkanObject():
structs: dict[str, Struct] = 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)
flags: dict[str, Flags] = 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)