yuzu/Vulkan-Headers
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Headers synced 2024-11-21 06:26:00 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Update for Vulkan-Docs 1.3.285

Browse source
This commit is contained in:
Jon Leech 2024-05-10 01:34:47 -07:00 committed by Jon Leech
parent 4bc77c26ff
commit 5677bafb82
14 changed files with 5175 additions and 4569 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
include/vulkan/vulkan.cppm
View file

@ -2510,6 +2510,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationExtensionName;
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationSpecVersion;
//=== VK_MESA_image_alignment_control ===
using VULKAN_HPP_NAMESPACE::MESAImageAlignmentControlExtensionName;
using VULKAN_HPP_NAMESPACE::MESAImageAlignmentControlSpecVersion;
//========================
//=== CONSTEXPR VALUEs ===
//========================
@ -4360,6 +4364,11 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_ray_tracing_validation ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV;
//=== VK_MESA_image_alignment_control ===
using VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA;
//===============
//=== HANDLEs ===
//===============

45
include/vulkan/vulkan.hpp
View file

@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 284, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 285, "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)
@ -6144,7 +6144,7 @@ namespace VULKAN_HPP_NAMESPACE
using RemoteAddressNV = void *;
using SampleMask = uint32_t;
template <typename Type, Type value = 0>
template <typename Type, Type value = Type{}>
struct CppType
{
};
@ -8688,6 +8688,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationExtensionName = VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationSpecVersion = VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION;
//=== VK_MESA_image_alignment_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlExtensionName = VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlSpecVersion = VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION;
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
@ -16704,6 +16708,43 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_MESA_image_alignment_control ===
template <>
struct StructExtends<PhysicalDeviceImageAlignmentControlFeaturesMESA, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageAlignmentControlFeaturesMESA, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceImageAlignmentControlPropertiesMESA, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<ImageAlignmentControlCreateInfoMESA, ImageCreateInfo>
{
enum
{
value = true
};
};
#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL

29
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 284
#define VK_HEADER_VERSION 285
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
@ -1114,6 +1114,9 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001,
VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002,
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 = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@ -19169,6 +19172,30 @@ typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
// VK_MESA_image_alignment_control is a preprocessor guard. Do not pass it to API calls.
#define VK_MESA_image_alignment_control 1
#define VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION 1
#define VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME "VK_MESA_image_alignment_control"
typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA {
VkStructureType sType;
void* pNext;
VkBool32 imageAlignmentControl;
} VkPhysicalDeviceImageAlignmentControlFeaturesMESA;
typedef struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA {
VkStructureType sType;
void* pNext;
uint32_t supportedImageAlignmentMask;
} VkPhysicalDeviceImageAlignmentControlPropertiesMESA;
typedef struct VkImageAlignmentControlCreateInfoMESA {
VkStructureType sType;
const void* pNext;
uint32_t maximumRequestedAlignment;
} VkImageAlignmentControlCreateInfoMESA;
// 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

5
include/vulkan/vulkan_enums.hpp
View file

@ -1419,7 +1419,10 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV,
ePhysicalDeviceRawAccessChainsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV,
ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV,
ePhysicalDeviceRayTracingValidationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV
ePhysicalDeviceRayTracingValidationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV,
ePhysicalDeviceImageAlignmentControlFeaturesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA,
ePhysicalDeviceImageAlignmentControlPropertiesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA,
eImageAlignmentControlCreateInfoMESA = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA
};
enum class PipelineCacheHeaderVersion

14
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -437,7 +437,8 @@ namespace VULKAN_HPP_NAMESPACE
"VK_NV_descriptor_pool_overallocation",
"VK_NV_raw_access_chains",
"VK_NV_shader_atomic_float16_vector",
"VK_NV_ray_tracing_validation"
"VK_NV_ray_tracing_validation",
"VK_MESA_image_alignment_control"
};
return deviceExtensions;
}
@ -2312,7 +2313,13 @@ namespace VULKAN_HPP_NAMESPACE
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } }
{ "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_MESA_image_alignment_control",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } }
};
auto depIt = dependencies.find( extension );
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
@ -3076,7 +3083,8 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_raw_access_chains" ) ||
( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_NV_ray_tracing_validation" );
( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
( extension == "VK_MESA_image_alignment_control" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

5
include/vulkan/vulkan_handles.hpp
View file

@ -1833,6 +1833,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_ray_tracing_validation ===
struct PhysicalDeviceRayTracingValidationFeaturesNV;
//=== VK_MESA_image_alignment_control ===
struct PhysicalDeviceImageAlignmentControlFeaturesMESA;
struct PhysicalDeviceImageAlignmentControlPropertiesMESA;
struct ImageAlignmentControlCreateInfoMESA;
//===================================
//=== HANDLE forward declarations ===
//===================================

41
include/vulkan/vulkan_hash.hpp
View file

@ -5637,6 +5637,19 @@ namespace std
};
# endif /*VK_USE_PLATFORM_IOS_MVK*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA const & imageAlignmentControlCreateInfoMESA ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.sType );
VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.pNext );
VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.maximumRequestedAlignment );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImageBlit>
{
@ -9116,6 +9129,34 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA>
{
std::size_t operator()(
VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA const & physicalDeviceImageAlignmentControlFeaturesMESA ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.imageAlignmentControl );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA const & physicalDeviceImageAlignmentControlPropertiesMESA )
const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.supportedImageAlignmentMask );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT>
{

12
include/vulkan/vulkan_raii.hpp
View file

@ -12904,7 +12904,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE
@ -12964,7 +12964,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
}
VULKAN_HPP_NODISCARD
@ -17844,7 +17844,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX Pipeline::getExecutionGraphScratchSizeAMDX() const
@ -18436,7 +18436,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
}
template <typename DataType>
@ -18927,7 +18927,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
}
template <typename DataType>
@ -22574,7 +22574,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif
}
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT( *this, *reinterpret_cast<VkShaderEXT *>( &shader ), allocator );
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT( *this, *reinterpret_cast<VkShaderEXT *>( &shader ), allocator, result );
}
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ShaderEXT::getBinaryData() const

25
include/vulkan/vulkan_static_assertions.hpp
View file

@ -7581,4 +7581,29 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV>::value,
"PhysicalDeviceRayTracingValidationFeaturesNV is not nothrow_move_constructible!" );
//=== VK_MESA_image_alignment_control ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA ) ==
sizeof( VkPhysicalDeviceImageAlignmentControlFeaturesMESA ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA>::value,
"PhysicalDeviceImageAlignmentControlFeaturesMESA is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA ) ==
sizeof( VkPhysicalDeviceImageAlignmentControlPropertiesMESA ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA>::value,
"PhysicalDeviceImageAlignmentControlPropertiesMESA is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA ) == sizeof( VkImageAlignmentControlCreateInfoMESA ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA>::value,
"ImageAlignmentControlCreateInfoMESA is not nothrow_move_constructible!" );
#endif

9363
include/vulkan/vulkan_structs.hpp
View file

File diff suppressed because it is too large Load diff

3
include/vulkan/vulkan_to_string.hpp
View file

@ -4554,6 +4554,9 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV";
case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV: return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV";
case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV: return "PhysicalDeviceRayTracingValidationFeaturesNV";
case StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA: return "PhysicalDeviceImageAlignmentControlFeaturesMESA";
case StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA: return "PhysicalDeviceImageAlignmentControlPropertiesMESA";
case StructureType::eImageAlignmentControlCreateInfoMESA: return "ImageAlignmentControlCreateInfoMESA";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}

45
registry/reg.py
View file

@ -436,6 +436,12 @@ class Registry:
self.cmddict = {}
"dictionary of CmdInfo objects keyed by command name"
self.aliasdict = {}
"dictionary of type and command names mapped to their alias, such as VkFooKHR -> VkFoo"
self.enumvaluedict = {}
"dictionary of enum values mapped to their type, such as VK_FOO_VALUE -> VkFoo"
self.apidict = {}
"dictionary of FeatureInfo objects for `<feature>` elements keyed by API name"
@ -548,6 +554,22 @@ class Registry:
"""Specify a feature name regexp to break on when generating features."""
self.breakPat = re.compile(regexp)
def addEnumValue(self, enum, type_name):
"""Track aliasing and map back from enum values to their type"""
# Record alias, if any
value = enum.get('name')
alias = enum.get('alias')
if alias:
self.aliasdict[value] = alias
# Map the value back to the type
if type_name in self.aliasdict:
type_name = self.aliasdict[type_name]
if value in self.enumvaluedict:
# Some times the same enum is defined by multiple extensions
assert(type_name == self.enumvaluedict[value])
else:
self.enumvaluedict[value] = type_name
def parseTree(self):
"""Parse the registry Element, once created"""
# This must be the Element for the root <registry>
@ -571,6 +593,9 @@ class Registry:
else:
stripNonmatchingAPIs(self.reg, self.genOpts.apiname, actuallyDelete = True)
self.aliasdict = {}
self.enumvaluedict = {}
# Create dictionary of registry types from toplevel <types> tags
# and add 'name' attribute to each <type> tag (where missing)
# based on its <name> element.
@ -581,13 +606,20 @@ class Registry:
for type_elem in self.reg.findall('types/type'):
# If the <type> does not already have a 'name' attribute, set
# it from contents of its <name> tag.
if type_elem.get('name') is None:
name = type_elem.get('name')
if name is None:
name_elem = type_elem.find('name')
if name_elem is None or not name_elem.text:
raise RuntimeError("Type without a name!")
type_elem.set('name', name_elem.text)
name = name_elem.text
type_elem.set('name', name)
self.addElementInfo(type_elem, TypeInfo(type_elem), 'type', self.typedict)
# Record alias, if any
alias = type_elem.get('alias')
if alias:
self.aliasdict[name] = alias
# Create dictionary of registry enum groups from <enums> tags.
#
# Required <enums> attributes: 'name'. If no name is given, one is
@ -609,10 +641,14 @@ class Registry:
self.enumdict = {}
for enums in self.reg.findall('enums'):
required = (enums.get('type') is not None)
type_name = enums.get('name')
# Enum values are defined only for the type that is not aliased to something else.
assert(type_name not in self.aliasdict)
for enum in enums.findall('enum'):
enumInfo = EnumInfo(enum)
enumInfo.required = required
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
self.addEnumValue(enum, type_name)
# Create dictionary of registry commands from <command> tags
# and add 'name' attribute to each <command> tag (where missing)
@ -622,7 +658,7 @@ class Registry:
# Required <command> attributes: 'name' or <proto><name> tag contents
self.cmddict = {}
# List of commands which alias others. Contains
# [ aliasName, element ]
# [ name, aliasName, element ]
# for each alias
cmdAlias = []
for cmd in self.reg.findall('commands/command'):
@ -639,6 +675,7 @@ class Registry:
alias = cmd.get('alias')
if alias:
cmdAlias.append([name, alias, cmd])
self.aliasdict[name] = alias
# Now loop over aliases, injecting a copy of the aliased command's
# Element with the aliased prototype name replaced with the command
@ -713,6 +750,7 @@ class Registry:
if addEnumInfo:
enumInfo = EnumInfo(enum)
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
self.addEnumValue(enum, groupName)
sync_pipeline_stage_condition = dict()
sync_access_condition = dict()
@ -791,6 +829,7 @@ class Registry:
if addEnumInfo:
enumInfo = EnumInfo(enum)
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
self.addEnumValue(enum, groupName)
# Parse out all spirv tags in dictionaries
# Use addElementInfo to catch duplicates

92
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

56
registry/vk.xml
View file

@ -67,7 +67,7 @@ branch of the member gitlab server.
<tag name="KHR" author="Khronos" contact="Tom Olson @tomolson"/>
<tag name="KHX" author="Khronos" contact="Tom Olson @tomolson"/>
<tag name="EXT" author="Multivendor" contact="Jon Leech @oddhack"/>
<tag name="MESA" author="Mesa open source project" contact="Lina Versace @versalinyaa, Daniel Stone @fooishbar, David Airlie @airlied, Faith Ekstrand @gfxstrand"/>
<tag name="MESA" author="Mesa open source project" contact="Lina Versace @versalinyaa, Daniel Stone @fooishbar, David Airlie @airlied, Faith Ekstrand @gfxstrand, Hans-Kristian Arntzen @HansKristian-Work"/>
<tag name="INTEL" author="Intel Corporation" contact="Slawek Grajewski @sgrajewski"/>
<tag name="HUAWEI" author="Huawei Technologies Co. Ltd." contact="Pan Gao @PanGao-h, Juntao Li @Lawrenceleehw"/>
<tag name="VALVE" author="Valve Corporation" contact="Pierre-Loup Griffais @plagman, Joshua Ashton @Joshua-Ashton, Hans-Kristian Arntzen @HansKristian-Work"/>
@ -175,7 +175,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> 284</type>
#define <name>VK_HEADER_VERSION</name> 285</type>
<type api="vulkan" category="define" requires="VK_HEADER_VERSION">// Complete version of this file
#define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 3, VK_HEADER_VERSION)</type>
<type api="vulkansc" category="define">// Version of this file
@ -9123,6 +9123,21 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>shaderRawAccessChains</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceImageAlignmentControlFeaturesMESA" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>imageAlignmentControl</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceImageAlignmentControlPropertiesMESA" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="bitmask"><type>uint32_t</type> <name>supportedImageAlignmentMask</name></member>
</type>
<type category="struct" name="VkImageAlignmentControlCreateInfoMESA" structextends="VkImageCreateInfo">
<member values="VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>uint32_t</type> <name>maximumRequestedAlignment</name></member>
</type>
</types>
@ -24371,10 +24386,16 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_KHR_extension_575&quot;" name="VK_KHR_EXTENSION_575_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_VALVE_extension_576" number="576" author="VALVE" contact="Hans-Kristian Arntzen @HansKristian-Work" supported="disabled">
<extension name="VK_MESA_image_alignment_control" number="576" type="device" author="MESA" contact="Hans-Kristian Arntzen @HansKristian-Work" specialuse="d3demulation" supported="vulkan" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1">
<require>
<enum value="0" name="VK_VALVE_EXTENSION_576_SPEC_VERSION"/>
<enum value="&quot;VK_VALVE_extension_576&quot;" name="VK_VALVE_EXTENSION_576_EXTENSION_NAME"/>
<enum value="1" name="VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION"/>
<enum value="&quot;VK_MESA_image_alignment_control&quot;" name="VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME"/>
<type name="VkPhysicalDeviceImageAlignmentControlFeaturesMESA"/>
<type name="VkPhysicalDeviceImageAlignmentControlPropertiesMESA"/>
<type name="VkImageAlignmentControlCreateInfoMESA"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA"/>
</require>
</extension>
<extension name="VK_HUAWEI_extension_577" number="577" author="HUAWEI" contact="Ye Wang @wangye" supported="disabled">
@ -24422,6 +24443,25 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_583&quot;" name="VK_EXT_EXTENSION_583_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_584" number="584" author="EXT" contact="James Jones @cubanismo" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_584_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_584&quot;" name="VK_EXT_EXTENSION_584_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_extension_585" number="585" author="EXT" contact="Shahbaz Youssefi @syoussefi" supported="disabled">
<require>
<enum value="0" name="VK_EXT_EXTENSION_585_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_585&quot;" name="VK_EXT_EXTENSION_585_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_IMG_extension_586" number="586" author="IMG" contact="James Fitzpatrick @jfitzpatrick-img" supported="disabled">
<require>
<enum value="0" name="VK_IMG_EXTENSION_586_SPEC_VERSION"/>
<enum value="&quot;VK_IMG_extension_586&quot;" name="VK_IMG_EXTENSION_586_EXTENSION_NAME"/>
<enum bitpos="4" extends="VkDependencyFlagBits" name="VK_DEPENDENCY_EXTENSION_586_BIT_IMG"/>
</require>
</extension>
</extensions>
<formats>
<format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">
@ -26554,6 +26594,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
<spirvcapability name="RayTracingPositionFetchKHR">
<enable struct="VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR" feature="rayTracingPositionFetch" requires="VK_KHR_ray_tracing_position_fetch"/>
</spirvcapability>
<spirvcapability name="RayQueryPositionFetchKHR">
<enable struct="VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR" feature="rayTracingPositionFetch" requires="VK_KHR_ray_tracing_position_fetch"/>
</spirvcapability>
<spirvcapability name="TileImageColorReadAccessEXT">
<enable struct="VkPhysicalDeviceShaderTileImageFeaturesEXT" feature="shaderTileImageColorReadAccess" requires="VK_EXT_shader_tile_image"/>
</spirvcapability>
@ -26581,9 +26624,6 @@ typedef void* <name>MTLSharedEvent_id</name>;
<spirvcapability name="QuadControlKHR">
<enable struct="VkPhysicalDeviceShaderQuadControlFeaturesKHR" feature="shaderQuadControl" requires="VK_KHR_shader_quad_control"/>
</spirvcapability>
<spirvcapability name="MaximallyReconvergesKHR">
<enable struct="VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR" feature="shaderMaximalReconvergence" requires="VK_KHR_shader_maximal_reconvergence"/>
</spirvcapability>
<spirvcapability name="RawAccessChainsNV">
<enable struct="VkPhysicalDeviceRawAccessChainsFeaturesNV" feature="shaderRawAccessChains" requires="VK_NV_raw_access_chains"/>
</spirvcapability>