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

Update for Vulkan-Docs 1.4.309

Browse source
This commit is contained in:
Jon Leech 2025-02-21 03:21:11 -08:00 • committed by Jon Leech
parent 234c4b7370
commit 952f776f65
18 changed files with 11864 additions and 177 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Makefile.release
View file

@ -57,6 +57,7 @@ update-headers:
# Top-level scripts / XML to install
SCRIPTS = \
$(SPEC)/scripts/base_generator.py \
$(SPEC)/scripts/cgenerator.py \
$(SPEC)/scripts/generator.py \
$(SPEC)/scripts/parse_dependency.py \
@ -64,6 +65,7 @@ SCRIPTS = \
$(SPEC)/scripts/stripAPI.py \
$(SPEC)/scripts/apiconventions.py \
$(SPEC)/scripts/vkconventions.py \
$(SPEC)/scripts/vulkan_object.py \
$(SPEC)/xml/vk.xml \
$(SPEC)/xml/video.xml \
$(REGISTRY)/specs/latest/validation/validusage.json

34
include/vulkan/vulkan.cppm
View file

@ -22,7 +22,9 @@ module;
#include <vulkan/vulkan_hash.hpp>
#include <vulkan/vulkan_raii.hpp>
#include <vulkan/vulkan_shared.hpp>
#include <vulkan/vulkan_to_string.hpp>
#ifndef VULKAN_HPP_NO_TO_STRING
# include <vulkan/vulkan_to_string.hpp>
#endif
export module vulkan_hpp;
@ -2726,6 +2728,12 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName;
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
using VULKAN_HPP_NAMESPACE::NVPresentMeteringExtensionName;
using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//========================
//=== CONSTEXPR VALUEs ===
//========================
@ -4806,6 +4814,12 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_vertex_attribute_robustness ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV;
using VULKAN_HPP_NAMESPACE::SetPresentConfigNV;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//===============
//=== HANDLEs ===
//===============
@ -8483,8 +8497,24 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//===============================================
//=== Required exports for vk::StructureChain ===
//===============================================
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
using std::tuple_element;
using std::tuple_size;
#endif
} // namespace std
// This VkFlags type is used as part of a bitfield in some structure.
// As it that can't be mimiced by vk-data types, we need to export just that!!
export VkGeometryInstanceFlagsKHR;
export VkGeometryInstanceFlagsKHR;

58
include/vulkan/vulkan.hpp
View file

@ -63,7 +63,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 307, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 309, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@ -8967,6 +8967,12 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessExtensionName = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringExtensionName = VK_NV_PRESENT_METERING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringSpecVersion = VK_NV_PRESENT_METERING_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
@ -15806,6 +15812,24 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<AccelerationStructureGeometryLinearSweptSpheresDataNV, AccelerationStructureGeometryKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AccelerationStructureGeometrySpheresDataNV, AccelerationStructureGeometryKHR>
{
enum
{
value = true
};
};
//=== VK_NV_linear_color_attachment ===
template <>
struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, PhysicalDeviceFeatures2>
@ -17950,6 +17974,36 @@ namespace VULKAN_HPP_NAMESPACE
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
template <>
struct StructExtends<SetPresentConfigNV, PresentInfoKHR>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePresentMeteringFeaturesNV, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDevicePresentMeteringFeaturesNV, DeviceCreateInfo>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
namespace detail
@ -22013,4 +22067,4 @@ namespace VULKAN_HPP_NAMESPACE
};
} // namespace detail
} // namespace VULKAN_HPP_NAMESPACE
#endif
#endif

27
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 307
#define VK_HEADER_VERSION 309
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1227,6 +1227,12 @@ 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,
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000,
#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001,
#endif
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
// VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a deprecated alias
@ -21347,6 +21353,25 @@ typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
// 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
#define VK_NV_PRESENT_METERING_EXTENSION_NAME "VK_NV_present_metering"
typedef struct VkSetPresentConfigNV {
VkStructureType sType;
const void* pNext;
uint32_t numFramesPerBatch;
uint32_t presentConfigFeedback;
} VkSetPresentConfigNV;
typedef struct VkPhysicalDevicePresentMeteringFeaturesNV {
VkStructureType sType;
void* pNext;
VkBool32 presentMetering;
} VkPhysicalDevicePresentMeteringFeaturesNV;
// VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_acceleration_structure 1
#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13

792
include/vulkan/vulkan_enums.hpp
View file

File diff suppressed because it is too large Load diff

44
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -469,7 +469,10 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_external_memory_metal",
#endif /*VK_USE_PLATFORM_METAL_EXT*/
"VK_KHR_depth_clamp_zero_one",
"VK_EXT_vertex_attribute_robustness"
"VK_EXT_vertex_attribute_robustness",
#if defined( VK_ENABLE_BETA_EXTENSIONS )
"VK_NV_present_metering"
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
};
return deviceExtensions;
}
@ -1054,12 +1057,18 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_spirv_1_4",
} } },
{ "VK_VERSION_1_2",
{ {
"VK_KHR_acceleration_structure",
} } } } },
{ "VK_KHR_ray_query",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_spirv_1_4",
} } },
{ "VK_VERSION_1_2",
{ {
"VK_KHR_acceleration_structure",
} } } } },
{ "VK_NV_shader_sm_builtins", { { "VK_VERSION_1_1", { {} } } } },
@ -1362,6 +1371,9 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_1",
{ {
"VK_KHR_vulkan_memory_model",
} } },
{ "VK_VERSION_1_2",
{ {
"VK_KHR_shader_maximal_reconvergence",
} } } } },
{ "VK_KHR_spirv_1_4",
@ -1714,7 +1726,8 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_spirv_1_4",
} } } } },
} } },
{ "VK_VERSION_1_2", { {} } } } },
{ "VK_EXT_ycbcr_2plane_444_formats",
{ { "VK_VERSION_1_0",
{ {
@ -2192,7 +2205,8 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_maintenance5",
} } } } },
} } },
{ "VK_VERSION_1_4", { {} } } } },
{ "VK_QCOM_tile_properties",
{ { "VK_VERSION_1_0",
{ {
@ -2220,7 +2234,8 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_maintenance3",
} } } } },
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_legacy_vertex_attributes",
{ { "VK_VERSION_1_0",
{ {
@ -2264,7 +2279,8 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } } } },
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_video_decode_av1",
{ { "VK_VERSION_1_0",
{ {
@ -2382,7 +2398,8 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_video_encode_queue",
"VK_KHR_format_feature_flags2",
} } } } },
} } },
{ "VK_VERSION_1_3", { {} } } } },
{ "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_cluster_acceleration_structure",
{ { "VK_VERSION_1_0",
@ -2398,8 +2415,12 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_buffer_device_address",
} } },
{ "VK_VERSION_1_2",
{ {
"VK_KHR_maintenance5",
} } } } },
} } },
{ "VK_VERSION_1_3", { {} } } } },
{ "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_MESA_image_alignment_control",
{ { "VK_VERSION_1_0",
@ -2416,8 +2437,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_KHR_video_maintenance2",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_video_decode_queue",
"VK_KHR_video_encode_queue",
"VK_KHR_video_queue",
} } } } },
{ "VK_HUAWEI_hdr_vivid",
{ { "VK_VERSION_1_0",
@ -3331,7 +3351,11 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" );
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_present_metering" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

2366
include/vulkan/vulkan_funcs.hpp
View file

File diff suppressed because it is too large Load diff

2637
include/vulkan/vulkan_handles.hpp
View file

File diff suppressed because it is too large Load diff

32
include/vulkan/vulkan_hash.hpp
View file

@ -11720,6 +11720,22 @@ namespace std
}
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV const & physicalDevicePresentMeteringFeaturesNV ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.presentMetering );
return seed;
}
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT>
{
@ -16094,6 +16110,22 @@ namespace std
}
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SetPresentConfigNV const & setPresentConfigNV ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.numFramesPerBatch );
VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.presentConfigFeedback );
return seed;
}
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
{

2293
include/vulkan/vulkan_raii.hpp
View file

File diff suppressed because it is too large Load diff

5
include/vulkan/vulkan_shared.hpp
View file

@ -315,6 +315,9 @@ namespace VULKAN_HPP_NAMESPACE
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wcast-function-type"
# elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wcast-function-type"
# endif
template <typename HandleType>
@ -459,6 +462,8 @@ namespace VULKAN_HPP_NAMESPACE
# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
# pragma GCC diagnostic pop
# elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
# pragma clang diagnostic pop
# endif
} // namespace detail

16
include/vulkan/vulkan_static_assertions.hpp
View file

@ -8531,4 +8531,20 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT>::value,
"PhysicalDeviceVertexAttributeRobustnessFeaturesEXT is not nothrow_move_constructible!" );
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetPresentConfigNV ) == sizeof( VkSetPresentConfigNV ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SetPresentConfigNV>::value,
"SetPresentConfigNV is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV ) == sizeof( VkPhysicalDevicePresentMeteringFeaturesNV ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>::value,
"PhysicalDevicePresentMeteringFeaturesNV is not nothrow_move_constructible!" );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#endif

2147
include/vulkan/vulkan_structs.hpp
View file

File diff suppressed because it is too large Load diff

6
include/vulkan/vulkan_to_string.hpp
View file

@ -4948,6 +4948,10 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_METAL_EXT*/
case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR: return "PhysicalDeviceDepthClampZeroOneFeaturesKHR";
case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT: return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case StructureType::eSetPresentConfigNV: return "SetPresentConfigNV";
case StructureType::ePhysicalDevicePresentMeteringFeaturesNV: return "PhysicalDevicePresentMeteringFeaturesNV";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -9867,4 +9871,4 @@ namespace VULKAN_HPP_NAMESPACE
# pragma warning( pop )
#endif
#endif
#endif

787
registry/base_generator.py Normal file
View file

@ -0,0 +1,787 @@
#!/usr/bin/env python3 -i
#
# Copyright 2023-2025 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
import pickle
import os
import tempfile
from vulkan_object import (VulkanObject,
Extension, Version, Handle, Param, Queues, CommandScope, Command,
EnumField, Enum, Flag, Bitmask, Member, Struct,
FormatComponent, FormatPlane, Format,
SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline,
SpirvEnables, Spirv)
# These live in the Vulkan-Docs repo, but are pulled in via the
# Vulkan-Headers/registry folder
from generator import OutputGenerator, GeneratorOptions, write
from vkconventions import VulkanConventions
# An API style convention object
vulkanConventions = VulkanConventions()
# Helpers to keep things cleaner
def splitIfGet(elem, name):
return elem.get(name).split(',') if elem.get(name) is not None and elem.get(name) != '' else None
def textIfFind(elem, name):
return elem.find(name).text if elem.find(name) is not None else None
def intIfGet(elem, name):
return None if elem.get(name) is None else int(elem.get(name), 0)
def boolGet(elem, name) -> bool:
return elem.get(name) is not None and elem.get(name) == "true"
def getQueues(elem) -> Queues:
queues = 0
queues_list = splitIfGet(elem, 'queues')
if queues_list is not None:
queues |= Queues.TRANSFER if 'transfer' in queues_list else 0
queues |= Queues.GRAPHICS if 'graphics' in queues_list else 0
queues |= Queues.COMPUTE if 'compute' in queues_list else 0
queues |= Queues.PROTECTED if 'protected' in queues_list else 0
queues |= Queues.SPARSE_BINDING if 'sparse_binding' in queues_list else 0
queues |= Queues.OPTICAL_FLOW if 'opticalflow' in queues_list else 0
queues |= Queues.DECODE if 'decode' in queues_list else 0
queues |= Queues.ENCODE if 'encode' in queues_list else 0
return queues
# Shared object used by Sync elements that do not have ones
maxSyncSupport = SyncSupport(None, None, True)
maxSyncEquivalent = SyncEquivalent(None, None, True)
# Helpers to set GeneratorOptions options globally
def SetOutputFileName(fileName: str) -> None:
global globalFileName
globalFileName = fileName
def SetOutputDirectory(directory: str) -> None:
global globalDirectory
globalDirectory = directory
def SetTargetApiName(apiname: str) -> None:
global globalApiName
globalApiName = apiname
def SetMergedApiNames(names: str) -> None:
global mergedApiNames
mergedApiNames = names
cachingEnabled = False
def EnableCaching() -> None:
global cachingEnabled
cachingEnabled = True
# This class is a container for any source code, data, or other behavior that is necessary to
# customize the generator script for a specific target API variant (e.g. Vulkan SC). As such,
# all of these API-specific interfaces and their use in the generator script are part of the
# contract between this repository and its downstream users. Changing or removing any of these
# interfaces or their use in the generator script will have downstream effects and thus
# should be avoided unless absolutely necessary.
class APISpecific:
# Version object factory method
@staticmethod
def createApiVersion(targetApiName: str, name: str) -> Version:
match targetApiName:
# Vulkan SC specific API version creation
case 'vulkansc':
nameApi = name.replace('VK_', 'VK_API_')
nameApi = nameApi.replace('VKSC_', 'VKSC_API_')
nameString = f'"{name}"'
return Version(name, nameString, nameApi)
# Vulkan specific API version creation
case 'vulkan':
nameApi = name.replace('VK_', 'VK_API_')
nameString = f'"{name}"'
return Version(name, nameString, nameApi)
# This Generator Option is used across all generators.
# After years of use, it has shown that most the options are unified across each generator (file)
# as it is easier to modify things per-file that need the difference
class BaseGeneratorOptions(GeneratorOptions):
def __init__(self,
customFileName = None,
customDirectory = None,
customApiName = None):
GeneratorOptions.__init__(self,
conventions = vulkanConventions,
filename = customFileName if customFileName else globalFileName,
directory = customDirectory if customDirectory else globalDirectory,
apiname = customApiName if customApiName else globalApiName,
mergeApiNames = mergedApiNames,
defaultExtensions = customApiName if customApiName else globalApiName,
emitExtensions = '.*',
emitSpirv = '.*',
emitFormats = '.*')
# These are used by the generator.py script
self.apicall = 'VKAPI_ATTR '
self.apientry = 'VKAPI_CALL '
self.apientryp = 'VKAPI_PTR *'
self.alignFuncParam = 48
#
# This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers
# It will grab all the data and form it into a single object the rest of the generators will use
class BaseGenerator(OutputGenerator):
def __init__(self):
OutputGenerator.__init__(self, None, None, None)
self.vk = VulkanObject()
self.targetApiName = globalApiName
# reg.py has a `self.featureName` but this is nicer because
# it will be either the Version or Extension object
self.currentExtension = None
self.currentVersion = None
# Will map alias to promoted name
# ex. ['VK_FILTER_CUBIC_IMG' : 'VK_FILTER_CUBIC_EXT']
# When generating any code, there is no reason so use the old name
self.enumAliasMap = dict()
self.enumFieldAliasMap = dict()
self.bitmaskAliasMap = dict()
self.flagAliasMap = dict()
self.structAliasMap = dict()
def write(self, data):
# Prevents having to check before writing
if data is not None and data != "":
write(data, file=self.outFile)
def beginFile(self, genOpts):
OutputGenerator.beginFile(self, genOpts)
self.filename = genOpts.filename
# No gen*() command to get these, so do it manually
for platform in self.registry.tree.findall('platforms/platform'):
self.vk.platforms[platform.get('name')] = platform.get('protect')
for tags in self.registry.tree.findall('tags'):
for tag in tags.findall('tag'):
self.vk.vendorTags.append(tag.get('name'))
# No way known to get this from the XML
self.vk.queueBits[Queues.TRANSFER] = 'VK_QUEUE_TRANSFER_BIT'
self.vk.queueBits[Queues.GRAPHICS] = 'VK_QUEUE_GRAPHICS_BIT'
self.vk.queueBits[Queues.COMPUTE] = 'VK_QUEUE_COMPUTE_BIT'
self.vk.queueBits[Queues.PROTECTED] = 'VK_QUEUE_PROTECTED_BIT'
self.vk.queueBits[Queues.SPARSE_BINDING] = 'VK_QUEUE_SPARSE_BINDING_BIT'
self.vk.queueBits[Queues.OPTICAL_FLOW] = 'VK_QUEUE_OPTICAL_FLOW_BIT_NV'
self.vk.queueBits[Queues.DECODE] = 'VK_QUEUE_VIDEO_DECODE_BIT_KHR'
self.vk.queueBits[Queues.ENCODE] = 'VK_QUEUE_VIDEO_ENCODE_BIT_KHR'
# This function should be overloaded
def generate(self):
print("WARNING: This should not be called from the child class")
return
# This function is dense, it does all the magic to set the right extensions dependencies!
#
# The issue is if 2 extension expose a command, genCmd() will only
# show one of the extension, at endFile() we can finally go through
# and update which things depend on which extensions
#
# self.featureDictionary is built for use in the reg.py framework
# Details found in Vulkan-Docs/scripts/scriptgenerator.py
def applyExtensionDependency(self):
for extension in self.vk.extensions.values():
# dict.key() can be None, so need to double loop
dict = self.featureDictionary[extension.name]['command']
# "required" == None
# or
# an additional feature dependency, which is a boolean expression of
# one or more extension and/or core version names
for required in dict:
for commandName in dict[required]:
# Skip commands removed in the target API
# This check is needed because parts of the base generator code bypass the
# dependency resolution logic in the registry tooling and thus the generator
# may attempt to generate code for commands which are not supported in the
# target API variant, thus this check needs to happen even if any specific
# target API variant may not specifically need it
if not commandName in self.vk.commands:
continue
command = self.vk.commands[commandName]
# Make sure list is unique
command.extensions.extend([extension] if extension 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
dict = self.featureDictionary[extension.name]['enumconstant']
for required in dict:
# group can be a Enum or Bitmask
for group in dict[required]:
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]))
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 [])
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
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]))
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 [])
# Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions
#
# Sometimes two extensions enable an Enum, but the newer extension version has extra flags allowed
# This information seems to be implicit, so need to update it here
# Go through each Flag and append the Enum extension to it
#
# ex. VkAccelerationStructureTypeKHR where GENERIC_KHR is not allowed with just VK_NV_ray_tracing
# This only works because the values are aliased as well, making the KHR a superset enum
for extension in self.vk.extensions.values():
dict = self.featureDictionary[extension.name]['enum']
for required in dict:
for group in dict[required]:
for enumName in dict[required][group]:
isAlias = enumName in self.enumAliasMap
enumName = self.enumAliasMap[enumName] if isAlias else enumName
if enumName in self.vk.enums:
enum = self.vk.enums[enumName]
enum.extensions.extend([extension] if extension 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 [])
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 [])
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 [])
dict = self.featureDictionary[extension.name]['bitmask']
for required in dict:
for group in dict[required]:
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
if bitmaskName in self.vk.bitmasks:
bitmask = self.vk.bitmasks[bitmaskName]
bitmask.extensions.extend([extension] if extension 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 [])
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 [])
# Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension
for extension in self.vk.extensions.values():
dict = self.featureDictionary[extension.name]['struct']
for required in dict:
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
if structName in self.vk.structs:
struct = self.vk.structs[structName]
struct.extensions.extend([extension] if extension 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
for command in self.vk.commands.values():
for member in command.params:
if member.type in self.structAliasMap:
member.type = self.structAliasMap[member.type]
def endFile(self):
# This is the point were reg.py has ran, everything is collected
# We do some post processing now
self.applyExtensionDependency()
# Use structs and commands to find which things are returnedOnly
for struct in [x for x in self.vk.structs.values() if not x.returnedOnly]:
for enum in [self.vk.enums[x.type] for x in struct.members if x.type in self.vk.enums]:
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 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
# Turn handle parents into pointers to classes
for handle in [x for x in self.vk.handles.values() if x.parent is not None]:
handle.parent = self.vk.handles[handle.parent]
# search up parent chain to see if instance or device
for handle in [x for x in self.vk.handles.values()]:
next_parent = handle.parent
while (not handle.instance and not handle.device):
handle.instance = next_parent.name == 'VkInstance'
handle.device = next_parent.name == 'VkDevice'
next_parent = next_parent.parent
maxSyncSupport.queues = Queues.ALL
maxSyncSupport.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
maxSyncEquivalent.accesses = self.vk.bitmasks['VkAccessFlagBits2'].flags
maxSyncEquivalent.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
# All inherited generators should run from here
self.generate()
if cachingEnabled:
cachePath = os.path.join(tempfile.gettempdir(), f'vkobject_{os.getpid()}')
if not os.path.isfile(cachePath):
cacheFile = open(cachePath, 'wb')
pickle.dump(self.vk, cacheFile)
cacheFile.close()
# This should not have to do anything but call into OutputGenerator
OutputGenerator.endFile(self)
#
# Bypass the entire processing and load in the VkObject data
# Still need to handle the beingFile/endFile for reg.py
def generateFromCache(self, cacheVkObjectData, genOpts):
OutputGenerator.beginFile(self, genOpts)
self.filename = genOpts.filename
self.vk = cacheVkObjectData
self.generate()
OutputGenerator.endFile(self)
#
# Processing point at beginning of each extension definition
def beginFeature(self, interface, emit):
OutputGenerator.beginFeature(self, interface, emit)
platform = interface.get('platform')
self.featureExtraProtec = self.vk.platforms[platform] if platform in self.vk.platforms else None
protect = self.vk.platforms[platform] if platform in self.vk.platforms else None
name = interface.get('name')
if interface.tag == 'extension':
instance = interface.get('type') == 'instance'
device = not instance
depends = interface.get('depends')
vendorTag = interface.get('author')
platform = interface.get('platform')
provisional = boolGet(interface, 'provisional')
promotedto = interface.get('promotedto')
deprecatedby = interface.get('deprecatedby')
obsoletedby = interface.get('obsoletedby')
specialuse = splitIfGet(interface, 'specialuse')
# Not sure if better way to get this info
specVersion = self.featureDictionary[name]['enumconstant'][None][None][0]
nameString = self.featureDictionary[name]['enumconstant'][None][None][1]
self.currentExtension = Extension(name, nameString, specVersion, instance, device, depends, vendorTag,
platform, protect, provisional, promotedto, deprecatedby,
obsoletedby, specialuse)
self.vk.extensions[name] = self.currentExtension
else: # version
number = interface.get('number')
if number != '1.0':
self.currentVersion = APISpecific.createApiVersion(self.targetApiName, name)
self.vk.versions[name] = self.currentVersion
def endFeature(self):
OutputGenerator.endFeature(self)
self.currentExtension = None
self.currentVersion = None
#
# All <command> from XML
def genCmd(self, cmdinfo, name, alias):
OutputGenerator.genCmd(self, cmdinfo, name, alias)
params = []
for param in cmdinfo.elem.findall('param'):
paramName = param.find('name').text
paramType = textIfFind(param, 'type')
paramAlias = param.get('alias')
cdecl = self.makeCParamDecl(param, 0)
pointer = '*' in cdecl or paramType.startswith('PFN_')
paramConst = 'const' in cdecl
fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
paramNoautovalidity = boolGet(param, 'noautovalidity')
nullTerminated = False
length = param.get('altlen') if param.get('altlen') is not None else param.get('len')
if length:
# we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
# This finds both
nullTerminated = 'null-terminated' in length
length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
length = None if length == 'null-terminated' else length
if fixedSizeArray and not length:
length = ','.join(fixedSizeArray)
# See Member::optional code for details of this
optionalValues = splitIfGet(param, 'optional')
optional = optionalValues is not None and optionalValues[0].lower() == "true"
optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
# externsync will be 'true' or expression
# if expression, it should be same as 'true'
externSync = boolGet(param, 'externsync')
externSyncPointer = None if externSync else splitIfGet(param, 'externsync')
if not externSync and externSyncPointer is not None:
externSync = True
params.append(Param(paramName, paramAlias, paramType, paramNoautovalidity,
paramConst, length, nullTerminated, pointer, fixedSizeArray,
optional, optionalPointer,
externSync, externSyncPointer, cdecl))
attrib = cmdinfo.elem.attrib
alias = attrib.get('alias')
tasks = splitIfGet(attrib, 'tasks')
queues = getQueues(attrib)
successcodes = splitIfGet(attrib, 'successcodes')
errorcodes = splitIfGet(attrib, 'errorcodes')
cmdbufferlevel = attrib.get('cmdbufferlevel')
primary = cmdbufferlevel is not None and 'primary' in cmdbufferlevel
secondary = cmdbufferlevel is not None and 'secondary' in cmdbufferlevel
renderpass = attrib.get('renderpass')
renderpass = CommandScope.NONE if renderpass is None else getattr(CommandScope, renderpass.upper())
videocoding = attrib.get('videocoding')
videocoding = CommandScope.NONE if videocoding is None else getattr(CommandScope, videocoding.upper())
protoElem = cmdinfo.elem.find('proto')
returnType = textIfFind(protoElem, 'type')
decls = self.makeCDecls(cmdinfo.elem)
cPrototype = decls[0]
cFunctionPointer = decls[1]
protect = self.currentExtension.protect if self.currentExtension is not None else None
# These coammds have no way from the XML to detect they would be an instance command
specialInstanceCommand = ['vkCreateInstance', 'vkEnumerateInstanceExtensionProperties','vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceVersion']
instance = len(params) > 0 and (params[0].type == 'VkInstance' or params[0].type == 'VkPhysicalDevice' or name in specialInstanceCommand)
device = not instance
implicitElem = cmdinfo.elem.find('implicitexternsyncparams')
implicitExternSyncParams = [x.text for x in implicitElem.findall('param')] if implicitElem else []
self.vk.commands[name] = Command(name, alias, protect, [], self.currentVersion,
returnType, params, instance, device,
tasks, queues, successcodes, errorcodes,
primary, secondary, renderpass, videocoding,
implicitExternSyncParams, cPrototype, cFunctionPointer)
#
# List the enum for the commands
# TODO - Seems empty groups like `VkDeviceDeviceMemoryReportCreateInfoEXT` do not show up in here
def genGroup(self, groupinfo, groupName, alias):
# There can be case where the Enum/Bitmask is in a protect, but the individual
# fields also have their own protect
groupProtect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
enumElem = groupinfo.elem
bitwidth = 32 if enumElem.get('bitwidth') is None else int(enumElem.get('bitwidth'))
fields = []
if enumElem.get('type') == "enum":
if alias is not None:
self.enumAliasMap[groupName] = alias
return
for elem in enumElem.findall('enum'):
fieldName = elem.get('name')
if elem.get('alias') is not None:
self.enumFieldAliasMap[fieldName] = elem.get('alias')
continue
negative = elem.get('dir') is not None
protect = elem.get('protect')
# 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, negative, protect, []))
self.vk.enums[groupName] = Enum(groupName, groupProtect, bitwidth, True, fields, [], [])
else: # "bitmask"
if alias is not None:
self.bitmaskAliasMap[groupName] = alias
return
for elem in enumElem.findall('enum'):
flagName = elem.get('name')
if elem.get('alias') is not None:
self.flagAliasMap[flagName] = elem.get('alias')
continue
flagMultiBit = False
flagZero = False
flagValue = intIfGet(elem, 'bitpos')
if flagValue is None:
flagValue = intIfGet(elem, 'value')
flagMultiBit = flagValue != 0
flagZero = flagValue == 0
protect = elem.get('protect')
# 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, flagValue, flagMultiBit, flagZero, []))
flagName = groupName.replace('FlagBits', 'Flags')
self.vk.bitmasks[groupName] = Bitmask(groupName, flagName, groupProtect, bitwidth, True, fields, [], [])
def genType(self, typeInfo, typeName, alias):
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
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
union = category == 'union'
returnedOnly = boolGet(typeElem, 'returnedonly')
allowDuplicate = boolGet(typeElem, 'allowduplicate')
extends = splitIfGet(typeElem, 'structextends')
extendedBy = self.registry.validextensionstructs[typeName] if len(self.registry.validextensionstructs[typeName]) > 0 else None
membersElem = typeInfo.elem.findall('.//member')
members = []
sType = None
for member in membersElem:
for comment in member.findall('comment'):
member.remove(comment)
name = textIfFind(member, 'name')
type = textIfFind(member, 'type')
sType = member.get('values') if member.get('values') is not None else sType
externSync = boolGet(member, 'externsync')
noautovalidity = boolGet(member, 'noautovalidity')
limittype = member.get('limittype')
nullTerminated = False
length = member.get('altlen') if member.get('altlen') is not None else member.get('len')
if length:
# we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
# This finds both
nullTerminated = 'null-terminated' in length
length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
length = None if length == 'null-terminated' else length
cdecl = self.makeCParamDecl(member, 0)
pointer = '*' in cdecl or type.startswith('PFN_')
const = 'const' in cdecl
# Some structs like VkTransformMatrixKHR have a 2D array
fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
if fixedSizeArray and not length:
length = ','.join(fixedSizeArray)
# if a pointer, this can be a something like:
# optional="true,false" for ppGeometries
# optional="false,true" for pPhysicalDeviceCount
# the first is if the variable itself is optional
# the second is the value of the pointer is optional;
optionalValues = splitIfGet(member, 'optional')
optional = optionalValues is not None and optionalValues[0].lower() == "true"
optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
members.append(Member(name, type, noautovalidity, limittype,
const, length, nullTerminated, pointer, fixedSizeArray,
optional, optionalPointer,
externSync, cdecl))
self.vk.structs[typeName] = Struct(typeName, extension, self.currentVersion, protect, members,
union, returnedOnly, sType, allowDuplicate, extends, extendedBy)
elif category == 'handle':
if alias is not None:
return
type = typeElem.get('objtypeenum')
# will resolve these later, the VulkanObjectType does not list things in dependent order
parent = typeElem.get('parent')
instance = typeName == 'VkInstance'
device = typeName == 'VkDevice'
dispatchable = typeElem.find('type').text == 'VK_DEFINE_HANDLE'
self.vk.handles[typeName] = Handle(typeName, type, protect, parent, instance, device, dispatchable)
elif category == 'define':
if typeName == 'VK_HEADER_VERSION':
self.vk.headerVersion = typeElem.find('name').tail.strip()
else:
# not all categories are used
# 'group'/'enum'/'bitmask' are routed to genGroup instead
# 'basetype'/'include' are only for headers
# 'funcpointer` ignore until needed
return
def genSpirv(self, spirvinfo, spirvName, alias):
OutputGenerator.genSpirv(self, spirvinfo, spirvName, alias)
spirvElem = spirvinfo.elem
name = spirvElem.get('name')
extension = True if spirvElem.tag == 'spirvextension' else False
capability = not extension
enables = []
for elem in spirvElem:
version = elem.attrib.get('version')
extensionEnable = elem.attrib.get('extension')
struct = elem.attrib.get('struct')
feature = elem.attrib.get('feature')
requires = elem.attrib.get('requires')
propertyEnable = elem.attrib.get('property')
member = elem.attrib.get('member')
value = elem.attrib.get('value')
enables.append(SpirvEnables(version, extensionEnable, struct, feature,
requires, propertyEnable, member, value))
self.vk.spirv.append(Spirv(name, extension, capability, enables))
def genFormat(self, format, formatinfo, alias):
OutputGenerator.genFormat(self, format, formatinfo, alias)
formatElem = format.elem
name = formatElem.get('name')
components = []
for component in formatElem.iterfind('component'):
type = component.get('name')
bits = component.get('bits')
numericFormat = component.get('numericFormat')
planeIndex = intIfGet(component, 'planeIndex')
components.append(FormatComponent(type, bits, numericFormat, planeIndex))
planes = []
for plane in formatElem.iterfind('plane'):
index = int(plane.get('index'))
widthDivisor = int(plane.get('widthDivisor'))
heightDivisor = int(plane.get('heightDivisor'))
compatible = plane.get('compatible')
planes.append(FormatPlane(index, widthDivisor, heightDivisor, compatible))
className = formatElem.get('class')
blockSize = int(formatElem.get('blockSize'))
texelsPerBlock = int(formatElem.get('texelsPerBlock'))
blockExtent = splitIfGet(formatElem, 'blockExtent')
packed = intIfGet(formatElem, 'packed')
chroma = formatElem.get('chroma')
compressed = formatElem.get('compressed')
spirvImageFormat = formatElem.find('spirvimageformat')
if spirvImageFormat is not None:
spirvImageFormat = spirvImageFormat.get('name')
self.vk.formats[name] = Format(name, className, blockSize, texelsPerBlock,
blockExtent, packed, chroma, compressed,
components, planes, spirvImageFormat)
def genSyncStage(self, sync):
OutputGenerator.genSyncStage(self, sync)
syncElem = sync.elem
support = maxSyncSupport
supportElem = syncElem.find('syncsupport')
if supportElem is not None:
queues = getQueues(supportElem)
stageNames = splitIfGet(supportElem, 'stage')
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
support = SyncSupport(queues, stages, False)
equivalent = maxSyncEquivalent
equivalentElem = syncElem.find('syncequivalent')
if equivalentElem is not None:
stageNames = splitIfGet(equivalentElem, 'stage')
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
accessNames = splitIfGet(equivalentElem, 'access')
accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
equivalent = SyncEquivalent(stages, accesses, False)
flagName = syncElem.get('name')
flag = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name == flagName]
# This check is needed because not all API variants have VK_KHR_synchronization2
if flag:
self.vk.syncStage.append(SyncStage(flag[0], support, equivalent))
def genSyncAccess(self, sync):
OutputGenerator.genSyncAccess(self, sync)
syncElem = sync.elem
support = maxSyncSupport
supportElem = syncElem.find('syncsupport')
if supportElem is not None:
queues = getQueues(supportElem)
stageNames = splitIfGet(supportElem, 'stage')
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
support = SyncSupport(queues, stages, False)
equivalent = maxSyncEquivalent
equivalentElem = syncElem.find('syncequivalent')
if equivalentElem is not None:
stageNames = splitIfGet(equivalentElem, 'stage')
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
accessNames = splitIfGet(equivalentElem, 'access')
accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
equivalent = SyncEquivalent(stages, accesses, False)
flagName = syncElem.get('name')
flag = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name == flagName]
# This check is needed because not all API variants have VK_KHR_synchronization2
if flag:
self.vk.syncAccess.append(SyncAccess(flag[0], support, equivalent))
def genSyncPipeline(self, sync):
OutputGenerator.genSyncPipeline(self, sync)
syncElem = sync.elem
name = syncElem.get('name')
depends = splitIfGet(syncElem, 'depends')
stages = []
for stageElem in syncElem.findall('syncpipelinestage'):
order = stageElem.get('order')
before = stageElem.get('before')
after = stageElem.get('after')
value = stageElem.text
stages.append(SyncPipelineStage(order, before, after, value))
self.vk.syncPipeline.append(SyncPipeline(name, depends, stages))

286
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

105
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> 307</type>
#define <name>VK_HEADER_VERSION</name> 309</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
@ -6154,7 +6154,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkBool32</type> <name>arrayOfPointers</name></member>
<member noautovalidity="true"><type>VkDeviceOrHostAddressConstKHR</type> <name>data</name></member>
</type>
<type category="struct" name="VkAccelerationStructureGeometryLinearSweptSpheresDataNV">
<type category="struct" name="VkAccelerationStructureGeometryLinearSweptSpheresDataNV" structextends="VkAccelerationStructureGeometryKHR">
<member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkFormat</type> <name>vertexFormat</name></member>
@ -6169,7 +6169,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkRayTracingLssIndexingModeNV</type> <name>indexingMode</name></member>
<member><type>VkRayTracingLssPrimitiveEndCapsModeNV</type> <name>endCapsMode</name></member>
</type>
<type category="struct" name="VkAccelerationStructureGeometrySpheresDataNV">
<type category="struct" name="VkAccelerationStructureGeometrySpheresDataNV" structextends="VkAccelerationStructureGeometryKHR">
<member values="VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkFormat</type> <name>vertexFormat</name></member>
@ -6725,7 +6725,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkBool32</type> <name>supersampleFragmentShadingRates</name></member>
<member><type>VkBool32</type> <name>noInvocationFragmentShadingRates</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV" structextends="VkPhysicalDeviceProperties2">
<type category="struct" name="VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max"><type>VkSampleCountFlagBits</type> <name>maxFragmentShadingRateInvocationCount</name></member>
@ -9922,7 +9922,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>schedulingControls</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceSchedulingControlsPropertiesARM" structextends="VkPhysicalDeviceProperties2">
<type category="struct" name="VkPhysicalDeviceSchedulingControlsPropertiesARM" structextends="VkPhysicalDeviceProperties2" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkPhysicalDeviceSchedulingControlsFlagsARM</type> <name>schedulingControlsFlags</name></member>
@ -10144,9 +10144,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="bitmask"><type>VkShaderStageFlags</type> <name>cooperativeVectorSupportedStages</name></member>
<member><type>VkBool32</type> <name>cooperativeVectorTrainingFloat16Accumulation</name></member>
<member><type>VkBool32</type> <name>cooperativeVectorTrainingFloat32Accumulation</name></member>
<member><type>uint32_t</type> <name>maxCooperativeVectorComponents</name></member>
<member limittype="exact"><type>VkBool32</type> <name>cooperativeVectorTrainingFloat16Accumulation</name></member>
<member limittype="exact"><type>VkBool32</type> <name>cooperativeVectorTrainingFloat32Accumulation</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxCooperativeVectorComponents</name></member>
</type>
<type category="struct" name="VkConvertCooperativeVectorMatrixInfoNV">
<member values="VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV"><type>VkStructureType</type> <name>sType</name></member>
@ -10164,6 +10164,17 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkCooperativeVectorMatrixLayoutNV</type> <name>dstLayout</name></member>
<member><type>size_t</type> <name>dstStride</name></member>
</type>
<type category="struct" name="VkSetPresentConfigNV" structextends="VkPresentInfoKHR">
<member values="VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>uint32_t</type> <name>numFramesPerBatch</name></member>
<member><type>uint32_t</type> <name>presentConfigFeedback</name></member>
</type>
<type category="struct" name="VkPhysicalDevicePresentMeteringFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>presentMetering</name></member>
</type>
</types>
@ -18437,10 +18448,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkDescriptorUpdateTemplateEntry"/>
<type name="VkDescriptorUpdateTemplateCreateInfo"/>
<enum name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET"/>
<enum name="VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO"/>
<type name="VkPushDescriptorSetWithTemplateInfo"/>
<command name="vkCmdPushDescriptorSetWithTemplate"/>
<command name="vkCmdPushDescriptorSetWithTemplate2"/>
<enum name="VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO"/>
<type name="VkPushDescriptorSetWithTemplateInfo"/>
<command name="vkCmdPushDescriptorSetWithTemplate"/>
<command name="vkCmdPushDescriptorSetWithTemplate2"/>
<!-- Sparse resources are unsupported -->
<enum name="VK_QUEUE_SPARSE_BINDING_BIT"/>
@ -20760,7 +20771,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="descriptorIndexing" struct="VkPhysicalDeviceVulkan12Features"/>
</require>
</extension>
<extension name="VK_KHR_ray_tracing_pipeline" number="348" type="device" depends="VK_KHR_spirv_1_4+VK_KHR_acceleration_structure" author="KHR" contact="Daniel Koch @dgkoch" supported="vulkan" sortorder="1" ratified="vulkan">
<extension name="VK_KHR_ray_tracing_pipeline" number="348" type="device" depends="(VK_KHR_spirv_1_4,VK_VERSION_1_2)+VK_KHR_acceleration_structure" author="KHR" contact="Daniel Koch @dgkoch" supported="vulkan" sortorder="1" ratified="vulkan">
<require>
<enum value="1" name="VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_ray_tracing_pipeline&quot;" name="VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME"/>
@ -20811,7 +20822,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="rayTraversalPrimitiveCulling" struct="VkPhysicalDeviceRayTracingPipelineFeaturesKHR"/>
</require>
</extension>
<extension name="VK_KHR_ray_query" number="349" type="device" depends="VK_KHR_spirv_1_4+VK_KHR_acceleration_structure" author="KHR" contact="Daniel Koch @dgkoch" supported="vulkan" sortorder="1" ratified="vulkan">
<extension name="VK_KHR_ray_query" number="349" type="device" depends="(VK_KHR_spirv_1_4,VK_VERSION_1_2)+VK_KHR_acceleration_structure" author="KHR" contact="Daniel Koch @dgkoch" supported="vulkan" sortorder="1" ratified="vulkan">
<require>
<enum value="1" name="VK_KHR_RAY_QUERY_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_ray_query&quot;" name="VK_KHR_RAY_QUERY_EXTENSION_NAME"/>
@ -21998,7 +22009,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="shaderImageInt64Atomics" struct="VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT"/>
</require>
</extension>
<extension name="VK_KHR_shader_quad_control" number="236" type="device" depends="VK_VERSION_1_1+VK_KHR_vulkan_memory_model+VK_KHR_shader_maximal_reconvergence" author="KHR" contact="Tobias Hector @tobski" supported="vulkan" ratified="vulkan">
<extension name="VK_KHR_shader_quad_control" number="236" type="device" depends="((VK_VERSION_1_1+VK_KHR_vulkan_memory_model),VK_VERSION_1_2)+VK_KHR_shader_maximal_reconvergence" author="KHR" contact="Tobias Hector @tobski" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_shader_quad_control&quot;" name="VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME"/>
@ -23467,7 +23478,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="rayTracingMotionBlur" struct="VkPhysicalDeviceRayTracingMotionBlurFeaturesNV"/>
</require>
</extension>
<extension name="VK_EXT_mesh_shader" number="329" type="device" depends="VK_KHR_spirv_1_4" author="EXT" sortorder="1" contact="Christoph Kubisch @pixeljetstream" supported="vulkan">
<extension name="VK_EXT_mesh_shader" number="329" type="device" depends="VK_KHR_spirv_1_4,VK_VERSION_1_2" author="EXT" sortorder="1" contact="Christoph Kubisch @pixeljetstream" supported="vulkan">
<require>
<enum value="1" name="VK_EXT_MESH_SHADER_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_mesh_shader&quot;" name="VK_EXT_MESH_SHADER_EXTENSION_NAME"/>
@ -25603,7 +25614,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command name="vkCmdSetDepthClampRangeEXT"/>
</require>
</extension>
<extension name="VK_KHR_pipeline_binary" number="484" author="KHR" contact="Stu Smith @stu-s" depends="VK_KHR_maintenance5" type="device" supported="vulkan" ratified="vulkan">
<extension name="VK_KHR_pipeline_binary" number="484" author="KHR" contact="Stu Smith @stu-s" depends="VK_KHR_maintenance5,VK_VERSION_1_4" type="device" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_KHR_PIPELINE_BINARY_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_pipeline_binary&quot;" name="VK_KHR_PIPELINE_BINARY_EXTENSION_NAME"/>
@ -25708,7 +25719,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="sciSyncFence,sciSyncSemaphore2" struct="VkPhysicalDeviceExternalSciSync2FeaturesNV"/>
<feature name="sciSyncImport,sciSyncExport" struct="VkPhysicalDeviceExternalSciSync2FeaturesNV"/>
</require>
<require comment="functionality re-used unmodified from VK_NV_external_sci_sync">
<require comment="functionality reused unmodified from VK_NV_external_sci_sync">
<enum extnumber="374" offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV"/>
<enum extnumber="374" offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV"/>
<enum extnumber="374" offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV"/>
@ -25788,7 +25799,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_NV_extension_494&quot;" name="VK_NV_EXTENSION_494_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_mutable_descriptor_type" number="495" type="device" supported="vulkan" ratified="vulkan" author="EXT" contact="Joshua Ashton @Joshua-Ashton,Hans-Kristian Arntzen @HansKristian-Work" specialuse="d3demulation" depends="VK_KHR_maintenance3">
<extension name="VK_EXT_mutable_descriptor_type" number="495" type="device" supported="vulkan" ratified="vulkan" author="EXT" contact="Joshua Ashton @Joshua-Ashton,Hans-Kristian Arntzen @HansKristian-Work" specialuse="d3demulation" depends="VK_KHR_maintenance3,VK_VERSION_1_1">
<require>
<enum value="1" name="VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_mutable_descriptor_type&quot;" name="VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME"/>
@ -25877,11 +25888,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_NV_extension_504&quot;" name="VK_NV_EXTENSION_504_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_505" number="505" author="EXT" contact="Jamie Madill @jmadill" type="device" supported="disabled">
<extension name="VK_EXT_extension_505" number="505" author="EXT" contact="Shahbaz Youssefi @syoussefi" type="device" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_505_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_505&quot;" name="VK_EXT_EXTENSION_505_EXTENSION_NAME"/>
<enum bitpos="5" extends="VkRenderingFlagBits" name="VK_RENDERING_EXTENSION_505_BIT_EXT"/>
<enum bitpos="2" extends="VkDeviceQueueCreateFlagBits" name="VK_DEVICE_QUEUE_CREATE_RESERVED_2_BIT_EXT"/>
</require>
</extension>
<extension name="VK_NV_low_latency2" number="506" author="NV" depends="VK_VERSION_1_2,VK_KHR_timeline_semaphore" contact="Charles Hansen @cshansen" type="device" supported="vulkan" nofeatures="true">
@ -25965,7 +25976,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="multiviewPerViewRenderAreas" struct="VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM"/>
</require>
</extension>
<extension name="VK_KHR_compute_shader_derivatives" number="512" type="device" depends="VK_KHR_get_physical_device_properties2" author="KHR" contact="Jean-Noe Morissette @MagicPoncho" supported="vulkan" ratified="vulkan">
<extension name="VK_KHR_compute_shader_derivatives" number="512" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="KHR" contact="Jean-Noe Morissette @MagicPoncho" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_compute_shader_derivatives&quot;" name="VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME"/>
@ -26421,7 +26432,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="11" extends="VkVideoEncodeH265CapabilityFlagBitsKHR" name="VK_VIDEO_ENCODE_H265_CAPABILITY_RESERVED_11_BIT_KHR"/>
</require>
</extension>
<extension name="VK_KHR_video_encode_quantization_map" number="554" type="device" depends="VK_KHR_video_encode_queue+VK_KHR_format_feature_flags2" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" supported="vulkan" ratified="vulkan">
<extension name="VK_KHR_video_encode_quantization_map" number="554" type="device" depends="VK_KHR_video_encode_queue+(VK_KHR_format_feature_flags2,VK_VERSION_1_3)" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" supported="vulkan" ratified="vulkan">
<require>
<enum value="2" name="VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_video_encode_quantization_map&quot;" name="VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME"/>
@ -26677,7 +26688,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_NV_extension_572&quot;" name="VK_NV_EXTENSION_572_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_device_generated_commands" number="573" author="EXT" type="device" depends="VK_KHR_buffer_device_address+VK_KHR_maintenance5" contact="Mike Blumenkrantz @zmike" supported="vulkan" ratified="vulkan">
<extension name="VK_EXT_device_generated_commands" number="573" author="EXT" type="device" depends="((VK_KHR_buffer_device_address,VK_VERSION_1_2)+VK_KHR_maintenance5),VK_VERSION_1_3" contact="Mike Blumenkrantz @zmike" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_device_generated_commands&quot;" name="VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME"/>
@ -26766,7 +26777,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="1" name="VK_KHR_MAINTENANCE_8_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_maintenance8&quot;" name="VK_KHR_MAINTENANCE_8_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR"/>
<enum bitpos="3" extends="VkPipelineCacheCreateFlagBits" name="VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR"/>
<enum bitpos="3" extends="VkPipelineCacheCreateFlagBits" name="VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR"/>
<type name="VkPhysicalDeviceMaintenance8FeaturesKHR"/>
<enum bitpos="5" extends="VkDependencyFlagBits" name="VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR"/>
@ -26863,7 +26874,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="4" extends="VkDependencyFlagBits" name="VK_DEPENDENCY_EXTENSION_586_BIT_IMG"/>
</require>
</extension>
<extension name="VK_KHR_video_maintenance2" number="587" author="KHR" contact="Daniel Rakos @aqnuep" type="device" depends="VK_KHR_video_decode_queue,VK_KHR_video_encode_queue" supported="vulkan" ratified="vulkan">
<extension name="VK_KHR_video_maintenance2" number="587" author="KHR" contact="Daniel Rakos @aqnuep" type="device" depends="VK_KHR_video_queue" supported="vulkan" ratified="vulkan">
<require>
<enum value="1" name="VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_video_maintenance2&quot;" name="VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME"/>
@ -27080,10 +27091,15 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_KHR_extension_613&quot;" name="VK_KHR_EXTENSION_613_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_NV_extension_614" number="614" author="NV" contact="Charles Hansen @cshansen" supported="disabled">
<extension name="VK_NV_present_metering" number="614" type="device" author="NV" contact="Charles Hansen @chansen" supported="vulkan" provisional="true">
<require>
<enum value="0" name="VK_NV_EXTENSION_614_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extension_614&quot;" name="VK_NV_EXTENSION_614_EXTENSION_NAME"/>
<enum value="1" name="VK_NV_PRESENT_METERING_SPEC_VERSION"/>
<enum value="&quot;VK_NV_present_metering&quot;" name="VK_NV_PRESENT_METERING_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<type name="VkSetPresentConfigNV"/>
<type name="VkPhysicalDevicePresentMeteringFeaturesNV"/>
<feature name="presentMetering" struct="VkPhysicalDevicePresentMeteringFeaturesNV"/>
</require>
</extension>
<extension name="VK_QCOM_extension_615" number="615" author="QCOM" contact="Matthew Netsch @mnetsch" supported="disabled">
@ -27092,6 +27108,30 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_QCOM_extension_615&quot;" name="VK_QCOM_EXTENSION_615_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_616" number="616" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_616_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_616&quot;" name="VK_EXT_EXTENSION_616_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_617" number="617" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
<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"/>
</require>
</extension>
<extension name="VK_EXT_extension_618" number="618" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_618_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_618&quot;" name="VK_EXT_EXTENSION_618_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_619" number="619" author="EXT" contact="Mike Blumenkrantz @zmike" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_619_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_619&quot;" name="VK_EXT_EXTENSION_619_EXTENSION_NAME"/>
</require>
</extension>
</extensions>
<formats>
<format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">
@ -28759,10 +28799,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<spirvextension name="SPV_NV_tensor_addressing">
<enable extension="VK_NV_cooperative_matrix2"/>
</spirvextension>
<spirvextension name="SPV_NV_linear_swept_spheres">
<enable extension="VK_NV_ray_tracing_linear_swept_spheres"/>
</spirvextension>
<spirvextension name="SPV_NV_cluster_acceleration_structure">
<enable extension="VK_NV_cluster_acceleration_structure"/>
</spirvextension>
<spirvextension name="SPV_NV_cooperative_vector">
<spirvextension name="SPV_NV_cooperative_vector">
<enable extension="VK_NV_cooperative_vector"/>
</spirvextension>
</spirvextensions>
@ -29310,7 +29353,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<spirvcapability name="RayTracingClusterAccelerationStructureNV">
<enable struct="VkPhysicalDeviceClusterAccelerationStructureFeaturesNV" feature="clusterAccelerationStructure" requires="VK_NV_cluster_acceleration_structure"/>
</spirvcapability>
<spirvcapability name="CooperativeVectorNV">
<spirvcapability name="CooperativeVectorNV">
<enable struct="VkPhysicalDeviceCooperativeVectorFeaturesNV" feature="cooperativeVector" requires="VK_NV_cooperative_vector"/>
</spirvcapability>
<spirvcapability name="CooperativeVectorTrainingNV">

404
registry/vulkan_object.py Normal file
View file

@ -0,0 +1,404 @@
#!/usr/bin/env python3 -i
#
# Copyright 2023-2025 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
from dataclasses import dataclass, field
from enum import IntFlag, Enum, auto
@dataclass
class Extension:
"""<extension>"""
name: str # ex) VK_KHR_SURFACE
nameString: str # marco with string, ex) VK_KHR_SURFACE_EXTENSION_NAME
specVersion: str # marco with string, ex) VK_KHR_SURFACE_SPEC_VERSION
# Only one will be True, the other is False
instance: bool
device: bool
depends: (str | None)
vendorTag: (str | None) # ex) EXT, KHR, etc
platform: (str | None) # ex) android
protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR
provisional: bool
promotedTo: (str | None) # ex) VK_VERSION_1_1
deprecatedBy: (str | None)
obsoletedBy: (str | None)
specialUse: list[str]
# These are here to allow for easy reverse lookups
# Quotes allow us to forward declare the dataclass
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)
# 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)
@dataclass
class Version:
"""
<feature> which represents a version
This will NEVER be Version 1.0, since having 'no version' is same as being 1.0
"""
name: str # ex) VK_VERSION_1_1
nameString: str # ex) "VK_VERSION_1_1" (no marco, so has quotes)
nameApi: str # ex) VK_API_VERSION_1_1
@dataclass
class Handle:
"""<type> which represents a dispatch handle"""
name: str # ex) VkBuffer
type: str # ex) VK_OBJECT_TYPE_BUFFER
protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR
parent: 'Handle' # Chain of parent handles, can be None
# Only one will be True, the other is False
instance: bool
device: bool
dispatchable: bool
def __lt__(self, other):
return self.name < other.name
@dataclass
class Param:
"""<command/param>"""
name: str
alias: str
type: str # ex) void, VkFormat, etc
noAutoValidity: bool
const: bool # type contains 'const'
length: (str | None) # the known length of pointer, will never be 'null-terminated'
nullTerminated: bool # If a UTF-8 string, it will be null-terminated
pointer: bool # type contains a pointer (include 'PFN' function pointers)
fixedSizeArray: list[str] # for VkTransformMatrixKHR:matrix this is [3, 4]
optional: bool
optionalPointer: bool # if type contains a pointer, is the pointer value optional
externSync: bool
externSyncPointer: list[str] # if type contains a pointer, might only specific members modified
# C string of member, example:
# - const void* pNext
# - VkFormat format
# - VkStructureType sType
cDeclaration: str
def __lt__(self, other):
return self.name < other.name
class Queues(IntFlag):
TRANSFER = auto() # VK_QUEUE_TRANSFER_BIT
GRAPHICS = auto() # VK_QUEUE_GRAPHICS_BIT
COMPUTE = auto() # VK_QUEUE_COMPUTE_BIT
PROTECTED = auto() # VK_QUEUE_PROTECTED_BIT
SPARSE_BINDING = auto() # VK_QUEUE_SPARSE_BINDING_BIT
OPTICAL_FLOW = auto() # VK_QUEUE_OPTICAL_FLOW_BIT_NV
DECODE = auto() # VK_QUEUE_VIDEO_DECODE_BIT_KHR
ENCODE = auto() # VK_QUEUE_VIDEO_ENCODE_BIT_KHR
ALL = TRANSFER | GRAPHICS | COMPUTE | PROTECTED | SPARSE_BINDING | OPTICAL_FLOW | DECODE | ENCODE
class CommandScope(Enum):
NONE = auto()
INSIDE = auto()
OUTSIDE = auto()
BOTH = auto()
@dataclass
class Command:
"""<command>"""
name: str # ex) vkCmdDraw
alias: str # 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
version: (Version | None) # None if Version 1.0
returnType: str # ex) void, VkResult, etc
params: list[Param] # Each parameter of the command
# Only one will be True, the other is False
instance: bool
device: bool
tasks: list[str] # ex) [ action, state, synchronization ]
queues: Queues # zero == No Queues found
successCodes: list[str] # ex) [ VK_SUCCESS, VK_INCOMPLETE ]
errorCodes: list[str] # ex) [ VK_ERROR_OUT_OF_HOST_MEMORY ]
# Shows support if command can be in a primary and/or secondary command buffer
primary: bool
secondary: bool
renderPass: CommandScope
videoCoding: CommandScope
implicitExternSyncParams: list[str]
# C prototype string - ex:
# VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
# const VkInstanceCreateInfo* pCreateInfo,
# const VkAllocationCallbacks* pAllocator,
# VkInstance* pInstance);
cPrototype: str
# function pointer typedef - ex:
# typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)
# (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
cFunctionPointer: str
def __lt__(self, other):
return self.name < other.name
@dataclass
class Member:
"""<member>"""
name: str # ex) sharingMode
type: str # ex) VkSharingMode
noAutoValidity: bool
limitType: (str | None) # ex) 'max', 'bitmask', 'bits', 'min,mul'
const: bool # type contains 'const'
length: (str | None) # the known length of pointer, will never be 'null-terminated'
nullTerminated: bool # If a UTF-8 string, it will be null-terminated
pointer: bool # type contains a pointer (include 'PFN' function pointers)
fixedSizeArray: list[str] # for VkTransformMatrixKHR:matrix this is [3, 4]
optional: bool
optionalPointer: bool # if type contains a pointer, is the pointer value optional
externSync: bool
# C string of member, example:
# - const void* pNext
# - VkFormat format
# - VkStructureType sType
cDeclaration: str
def __lt__(self, other):
return self.name < other.name
@dataclass
class Struct:
"""<type category="struct"> or <type category="union">"""
name: str # ex. VkBufferCreateInfo
extensions: list[Extension] # All extensions that enable the struct
version: (Version | None) # None if Version 1.0
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
members: list[Member]
union: bool # Unions are just a subset of a Structs
returnedOnly: bool
sType: (str | None) # ex) VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
allowDuplicate: bool # can have a pNext point to itself
# These use to be list['Struct'] but some circular loops occur and cause
# pydevd warnings and made debugging slow (30 seconds to index a Struct)
extends: list[str] # Struct names that this struct extends
extendedBy: list[str] # Struct names that can be extended by this struct
def __lt__(self, other):
return self.name < other.name
@dataclass
class EnumField:
"""<enum> of type enum"""
name: str # ex) VK_DYNAMIC_STATE_SCISSOR
negative: bool # True if negative values are allowed (ex. VkResult)
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
# 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
def __lt__(self, other):
return self.name < other.name
@dataclass
class Enum:
"""<enums> of type enum"""
name: str # ex) VkDynamicState
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
bitWidth: int # 32 or 64
returnedOnly: bool
fields: list[EnumField]
extensions: list[Extension] # None if part of 1.0 core
# Unique list of all extension that are involved in 'fields' (superset of 'extensions')
fieldExtensions: list[Extension]
def __lt__(self, other):
return self.name < other.name
@dataclass
class Flag:
"""<enum> of type bitmask"""
name: str # ex) VK_ACCESS_2_SHADER_READ_BIT
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
value: int
multiBit: bool # if true, more than one bit is set (ex) VK_SHADER_STAGE_ALL_GRAPHICS)
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
def __lt__(self, other):
return self.name < other.name
@dataclass
class Bitmask:
"""<enums> of type bitmask"""
name: str # ex) VkAccessFlagBits2
flagName: str # ex) VkAccessFlags2
protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
bitWidth: int # 32 or 64
returnedOnly: bool
flags: list[Flag]
extensions: list[Extension] # None if part of 1.0 core
# Unique list of all extension that are involved in 'flag' (superset of 'extensions')
flagExtensions: list[Extension]
def __lt__(self, other):
return self.name < other.name
@dataclass
class FormatComponent:
"""<format/component>"""
type: str # ex) R, G, B, A, D, S, etc
bits: str # will be an INT or 'compressed'
numericFormat: str # ex) UNORM, SINT, etc
planeIndex: (int | None) # None if no planeIndex in format
@dataclass
class FormatPlane:
"""<format/plane>"""
index: int
widthDivisor: int
heightDivisor: int
compatible: str
@dataclass
class Format:
"""<format>"""
name: str
className: str
blockSize: int
texelsPerBlock: int
blockExtent: list[str]
packed: (int | None) # None == not-packed
chroma: (str | None)
compressed: (str | None)
components: list[FormatComponent] # <format/component>
planes: list[FormatPlane] # <format/plane>
spirvImageFormat: (str | None)
@dataclass
class SyncSupport:
"""<syncsupport>"""
queues: Queues
stages: list[Flag] # VkPipelineStageFlagBits2
max: bool # If this supports max values
@dataclass
class SyncEquivalent:
"""<syncequivalent>"""
stages: list[Flag] # VkPipelineStageFlagBits2
accesses: list[Flag] # VkAccessFlagBits2
max: bool # If this equivalent to everything
@dataclass
class SyncStage:
"""<syncstage>"""
flag: Flag # VkPipelineStageFlagBits2
support: SyncSupport
equivalent: SyncEquivalent
@dataclass
class SyncAccess:
"""<syncaccess>"""
flag: Flag # VkAccessFlagBits2
support: SyncSupport
equivalent: SyncEquivalent
@dataclass
class SyncPipelineStage:
"""<syncpipelinestage>"""
order: (str | None)
before: (str | None)
after: (str | None)
value: str
@dataclass
class SyncPipeline:
"""<syncpipeline>"""
name: str
depends: list[str]
stages: list[SyncPipelineStage]
@dataclass
class SpirvEnables:
"""What is needed to enable the SPIR-V element"""
version: (str | None)
extension: (str | None)
struct: (str | None)
feature: (str | None)
requires: (str | None)
property: (str | None)
member: (str | None)
value: (str | None)
@dataclass
class Spirv:
"""<spirvextension> and <spirvcapability>"""
name: str
# Only one will be True, the other is False
extension: bool
capability: bool
enable: list[SpirvEnables]
# This is the global Vulkan Object that holds all the information from parsing the XML
# This class is designed so all generator scripts can use this to obtain data
@dataclass
class VulkanObject():
headerVersion: int = 0 # value of VK_HEADER_VERSION
extensions: dict[str, Extension] = field(default_factory=dict, init=False)
versions: dict[str, Version] = field(default_factory=dict, init=False)
handles: dict[str, Handle] = field(default_factory=dict, init=False)
commands: dict[str, Command] = 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)
bitmasks: dict[str, Bitmask] = 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)
syncAccess: list[SyncAccess] = field(default_factory=list, init=False)
syncPipeline: list[SyncPipeline] = field(default_factory=list, init=False)
spirv: list[Spirv] = field(default_factory=list, init=False)
# ex) [ xlib : VK_USE_PLATFORM_XLIB_KHR ]
platforms: dict[str, str] = field(default_factory=dict, init=False)
# list of all vendor Suffix names (KHR, EXT, etc. )
vendorTags: list[str] = field(default_factory=list, init=False)
# ex) [ Queues.COMPUTE : VK_QUEUE_COMPUTE_BIT ]
queueBits: dict[IntFlag, str] = field(default_factory=dict, init=False)