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

Update for Vulkan-Docs 1.4.329

Browse source
This commit is contained in:
Jon Leech 2025-10-10 01:36:45 +01:00 • committed by Jon Leech
parent f5fad0a209
commit 33d7f51258
17 changed files with 1775 additions and 1395 deletions
Download patch file Download diff file Expand all files Collapse all files

1914
include/vulkan/vulkan.cppm
View file

File diff suppressed because it is too large Load diff

42
include/vulkan/vulkan.hpp
View file

@ -8,14 +8,10 @@
#ifndef VULKAN_HPP
#define VULKAN_HPP
#include <vulkan/vulkan_hpp_macros.hpp>
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
# include <cassert>
# include <cstdlib>
# include <cstring>
import VULKAN_HPP_STD_MODULE;
#else
#if !defined( VULKAN_HPP_CXX_MODULE )
// clang-format off
# include <vulkan/vulkan_hpp_macros.hpp>
// clang-format on
# include <algorithm>
# include <array> // ArrayWrapperND
# include <cassert>
@ -38,6 +34,11 @@ import VULKAN_HPP_STD_MODULE;
# if defined( VULKAN_HPP_SUPPORT_SPAN )
# include <span>
# endif
#else
# include <cassert>
# include <cstdlib>
# include <cstring>
import VULKAN_HPP_STD_MODULE;
#endif
#include <vulkan/vulkan.h>
@ -57,7 +58,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif
#endif
static_assert( VK_HEADER_VERSION == 328, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 329, "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)
@ -9350,6 +9351,10 @@ namespace VULKAN_HPP_NAMESPACE
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;
//=== VK_KHR_shader_fma ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaExtensionName = VK_KHR_SHADER_FMA_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaSpecVersion = VK_KHR_SHADER_FMA_SPEC_VERSION;
//=== VK_EXT_depth_clamp_control ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlExtensionName = VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlSpecVersion = VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION;
@ -18956,6 +18961,25 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_KHR_shader_fma ===
template <>
struct StructExtends<PhysicalDeviceShaderFmaFeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceShaderFmaFeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_EXT_depth_clamp_control ===
template <>
struct StructExtends<PhysicalDeviceDepthClampControlFeaturesEXT, PhysicalDeviceFeatures2>

17
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 328
#define VK_HEADER_VERSION 329
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1303,6 +1303,7 @@ typedef enum VkStructureType {
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_SHADER_FMA_FEATURES_KHR = 1000579000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000,
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR = 1000584000,
@ -13747,6 +13748,20 @@ typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR {
// VK_KHR_shader_fma is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_shader_fma 1
#define VK_KHR_SHADER_FMA_SPEC_VERSION 1
#define VK_KHR_SHADER_FMA_EXTENSION_NAME "VK_KHR_shader_fma"
typedef struct VkPhysicalDeviceShaderFmaFeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 shaderFmaFloat16;
VkBool32 shaderFmaFloat32;
VkBool32 shaderFmaFloat64;
} VkPhysicalDeviceShaderFmaFeaturesKHR;
// VK_KHR_maintenance9 is a preprocessor guard. Do not pass it to API calls.
#define VK_KHR_maintenance9 1
#define VK_KHR_MAINTENANCE_9_SPEC_VERSION 1

5
include/vulkan/vulkan_enums.hpp
View file

@ -11,9 +11,7 @@
// include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private, include "vulkan/vulkan.hpp"
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
import VULKAN_HPP_STD_MODULE;
#else
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <type_traits> // for std::underlying_type
#endif
@ -1667,6 +1665,7 @@ namespace VULKAN_HPP_NAMESPACE
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,
ePhysicalDeviceShaderFmaFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR,
ePhysicalDeviceDepthClampControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT,
ePipelineViewportDepthClampControlCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT,
ePhysicalDeviceMaintenance9FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR,

11
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -8,9 +8,7 @@
#ifndef VULKAN_EXTENSION_INSPECTION_HPP
#define VULKAN_EXTENSION_INSPECTION_HPP
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
import VULKAN_HPP_STD_MODULE;
#else
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <map>
# include <set>
# include <string>
@ -480,6 +478,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_device_generated_commands",
"VK_KHR_maintenance8",
"VK_MESA_image_alignment_control",
"VK_KHR_shader_fma",
"VK_EXT_depth_clamp_control",
"VK_KHR_maintenance9",
"VK_KHR_video_maintenance2",
@ -3680,9 +3679,9 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_EXT_shader_float8" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) ||
( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) ||
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_maintenance9" ) ||
( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) ||
( extension == "VK_ARM_pipeline_opacity_micromap" )
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/

3
include/vulkan/vulkan_handles.hpp
View file

@ -2129,6 +2129,9 @@ namespace VULKAN_HPP_NAMESPACE
struct PhysicalDeviceImageAlignmentControlPropertiesMESA;
struct ImageAlignmentControlCreateInfoMESA;
//=== VK_KHR_shader_fma ===
struct PhysicalDeviceShaderFmaFeaturesKHR;
//=== VK_EXT_depth_clamp_control ===
struct PhysicalDeviceDepthClampControlFeaturesEXT;
struct PipelineViewportDepthClampControlCreateInfoEXT;

15
include/vulkan/vulkan_hash.hpp
View file

@ -13489,6 +13489,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR const & physicalDeviceShaderFmaFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat16 );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat32 );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat64 );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
{

4
include/vulkan/vulkan_hpp_macros.hpp
View file

@ -87,7 +87,7 @@
# define VULKAN_HPP_SUPPORT_SPAN
#endif
#if !defined( VULKAN_HPP_STD_MODULE ) && defined( VULKAN_HPP_ENABLE_STD_MODULE )
#if !defined( VULKAN_HPP_STD_MODULE ) && defined( __cpp_modules ) && defined( __cpp_lib_modules )
# define VULKAN_HPP_STD_MODULE std.compat
#endif
@ -310,10 +310,12 @@ namespace VULKAN_HPP_NAMESPACE
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment )
#else
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) = assignment
#endif
#if !defined( VULKAN_HPP_RAII_NAMESPACE )

2
include/vulkan/vulkan_raii.hpp
View file

@ -9,7 +9,7 @@
#define VULKAN_RAII_HPP
#include <vulkan/vulkan.hpp>
#if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <memory> // std::unique_ptr
# include <utility> // std::forward
#endif

40
include/vulkan/vulkan_shared.hpp
View file

@ -10,7 +10,7 @@
#include <vulkan/vulkan.hpp>
#if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <atomic> // std::atomic_size_t
#endif
@ -84,7 +84,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename DestructorType, typename Deleter>
struct SharedHeader
{
SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT
: parent( std::move( parent ) )
, deleter( std::move( deleter ) )
{
@ -97,7 +97,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename Deleter>
struct SharedHeader<NoDestructor, Deleter>
{
SharedHeader( Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
SharedHeader( Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
Deleter deleter;
};
@ -131,7 +131,7 @@ namespace VULKAN_HPP_NAMESPACE
public:
std::atomic_size_t m_ref_cnt{ 1 };
HeaderType m_header{};
HeaderType m_header;
};
//=====================================================================================================================
@ -282,7 +282,9 @@ namespace VULKAN_HPP_NAMESPACE
SharedHandle() = default;
template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value && !HasPoolType<T>::value>::type>
explicit SharedHandle( HandleType handle, SharedHandle<DestructorTypeOf<HandleType>> parent, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
explicit SharedHandle( HandleType handle,
SharedHandle<DestructorTypeOf<HandleType>> parent,
DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( parent ), std::move( deleter ) )
{
}
@ -299,7 +301,8 @@ namespace VULKAN_HPP_NAMESPACE
}
template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
explicit SharedHandle( HandleType handle, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT : BaseType( handle, std::move( deleter ) )
explicit SharedHandle( HandleType handle, DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( deleter ) )
{
}
@ -1051,9 +1054,9 @@ namespace VULKAN_HPP_NAMESPACE
struct ImageHeader : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>
{
ImageHeader( SharedHandle<DestructorTypeOf<Image>> parent,
typename SharedHandleTraits<Image>::deleter deleter = typename SharedHandleTraits<Image>::deleter(),
SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
ImageHeader( SharedHandle<DestructorTypeOf<Image>> parent,
typename SharedHandleTraits<Image>::deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<Image>::deleter() ),
SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
: SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>( std::move( parent ), std::move( deleter ) )
, swapchainOwned( swapchainOwned )
{
@ -1074,8 +1077,8 @@ namespace VULKAN_HPP_NAMESPACE
explicit SharedHandle( Image handle,
SharedHandle<DestructorTypeOf<Image>> parent,
SwapchainOwns swapchain_owned = SwapchainOwns::no,
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
SwapchainOwns swapchain_owned VULKAN_HPP_DEFAULT_ASSIGNMENT( SwapchainOwns::no ),
DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
{
}
@ -1092,18 +1095,19 @@ namespace VULKAN_HPP_NAMESPACE
struct SwapchainHeader
{
SwapchainHeader( SharedHandle<SurfaceKHR> surface,
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
typename SharedHandleTraits<SwapchainKHR>::deleter deleter = typename SharedHandleTraits<SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
SwapchainHeader( SharedHandle<SurfaceKHR> surface,
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
typename SharedHandleTraits<SwapchainKHR>::deleter deleter
VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<SwapchainKHR>::deleter() ) ) VULKAN_HPP_NOEXCEPT
: surface( std::move( surface ) )
, parent( std::move( parent ) )
, deleter( std::move( deleter ) )
{
}
SharedHandle<SurfaceKHR> surface{};
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent{};
typename SharedHandleTraits<SwapchainKHR>::deleter deleter{};
SharedHandle<SurfaceKHR> surface;
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent;
typename SharedHandleTraits<SwapchainKHR>::deleter deleter;
};
template <>
@ -1119,7 +1123,7 @@ namespace VULKAN_HPP_NAMESPACE
explicit SharedHandle( SwapchainKHR handle,
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
SharedHandle<SurfaceKHR> surface,
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
{
}

9
include/vulkan/vulkan_static_assertions.hpp
View file

@ -8999,6 +8999,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ImageAli
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA>::value,
"ImageAlignmentControlCreateInfoMESA is not nothrow_move_constructible!" );
//=== VK_KHR_shader_fma ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFmaFeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>::value,
"PhysicalDeviceShaderFmaFeaturesKHR is not nothrow_move_constructible!" );
//=== VK_EXT_depth_clamp_control ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClampControlFeaturesEXT ),

157
include/vulkan/vulkan_structs.hpp
View file

@ -11,8 +11,10 @@
// include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private, include "vulkan/vulkan.hpp"
#include <cstdlib> // free
#include <cstring> // strcmp
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <cstdlib> // free
# include <cstring> // strcmp
#endif
namespace VULKAN_HPP_NAMESPACE
{
@ -37817,16 +37819,16 @@ namespace VULKAN_HPP_NAMESPACE
}
public:
StructureType sType = StructureType::eDeviceCreateInfo;
const void * pNext = {};
DeviceCreateFlags flags = {};
uint32_t queueCreateInfoCount = {};
const DeviceQueueCreateInfo * pQueueCreateInfos = {};
VULKAN_HPP_DEPRECATED( "ignored" ) uint32_t enabledLayerCount;
VULKAN_HPP_DEPRECATED( "ignored" ) const char * const * ppEnabledLayerNames;
uint32_t enabledExtensionCount = {};
const char * const * ppEnabledExtensionNames = {};
const PhysicalDeviceFeatures * pEnabledFeatures = {};
StructureType sType = StructureType::eDeviceCreateInfo;
const void * pNext = {};
DeviceCreateFlags flags = {};
uint32_t queueCreateInfoCount = {};
const DeviceQueueCreateInfo * pQueueCreateInfos = {};
VULKAN_HPP_DEPRECATED( "ignored" ) uint32_t enabledLayerCount = {};
VULKAN_HPP_DEPRECATED( "ignored" ) const char * const * ppEnabledLayerNames = {};
uint32_t enabledExtensionCount = {};
const char * const * ppEnabledExtensionNames = {};
const PhysicalDeviceFeatures * pEnabledFeatures = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
@ -111491,6 +111493,137 @@ namespace VULKAN_HPP_NAMESPACE
using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features;
// wrapper struct for struct VkPhysicalDeviceShaderFmaFeaturesKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFmaFeaturesKHR.html
struct PhysicalDeviceShaderFmaFeaturesKHR
{
using NativeType = VkPhysicalDeviceShaderFmaFeaturesKHR;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFmaFeaturesKHR;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFmaFeaturesKHR( Bool32 shaderFmaFloat16_ = {},
Bool32 shaderFmaFloat32_ = {},
Bool32 shaderFmaFloat64_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, shaderFmaFloat16{ shaderFmaFloat16_ }
, shaderFmaFloat32{ shaderFmaFloat32_ }
, shaderFmaFloat64{ shaderFmaFloat64_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFmaFeaturesKHR( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceShaderFmaFeaturesKHR( VkPhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceShaderFmaFeaturesKHR( *reinterpret_cast<PhysicalDeviceShaderFmaFeaturesKHR const *>( &rhs ) )
{
}
PhysicalDeviceShaderFmaFeaturesKHR & operator=( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceShaderFmaFeaturesKHR & operator=( VkPhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceShaderFmaFeaturesKHR const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat16( Bool32 shaderFmaFloat16_ ) VULKAN_HPP_NOEXCEPT
{
shaderFmaFloat16 = shaderFmaFloat16_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat32( Bool32 shaderFmaFloat32_ ) VULKAN_HPP_NOEXCEPT
{
shaderFmaFloat32 = shaderFmaFloat32_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat64( Bool32 shaderFmaFloat64_ ) VULKAN_HPP_NOEXCEPT
{
shaderFmaFloat64 = shaderFmaFloat64_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceShaderFmaFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderFmaFeaturesKHR &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceShaderFmaFeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderFmaFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceShaderFmaFeaturesKHR *>( this );
}
operator VkPhysicalDeviceShaderFmaFeaturesKHR *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceShaderFmaFeaturesKHR *>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
std::tuple<StructureType const &, void * const &, Bool32 const &, Bool32 const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, shaderFmaFloat16, shaderFmaFloat32, shaderFmaFloat64 );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceShaderFmaFeaturesKHR const & ) const = default;
#else
bool operator==( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if defined( VULKAN_HPP_USE_REFLECT )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFmaFloat16 == rhs.shaderFmaFloat16 ) && ( shaderFmaFloat32 == rhs.shaderFmaFloat32 ) &&
( shaderFmaFloat64 == rhs.shaderFmaFloat64 );
# endif
}
bool operator!=( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
StructureType sType = StructureType::ePhysicalDeviceShaderFmaFeaturesKHR;
void * pNext = {};
Bool32 shaderFmaFloat16 = {};
Bool32 shaderFmaFloat32 = {};
Bool32 shaderFmaFloat64 = {};
};
#if 20 <= VULKAN_HPP_CPP_VERSION
template <>
struct CppType<VkPhysicalDeviceShaderFmaFeaturesKHR>
{
using Type = PhysicalDeviceShaderFmaFeaturesKHR;
};
#endif
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceShaderFmaFeaturesKHR>
{
using Type = PhysicalDeviceShaderFmaFeaturesKHR;
};
// wrapper struct for struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html
struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT

11
include/vulkan/vulkan_to_string.hpp
View file

@ -8,7 +8,9 @@
#ifndef VULKAN_TO_STRING_HPP
#define VULKAN_TO_STRING_HPP
#include <vulkan/vulkan.hpp>
#if !defined( VULKAN_HPP_CXX_MODULE )
# include <vulkan/vulkan.hpp>
#endif
// ignore warnings on using deprecated enum values in this header
#if defined( __clang__ ) || defined( __GNUC__ )
@ -19,10 +21,8 @@
# pragma warning( disable : 4996 )
#endif
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
import VULKAN_HPP_STD_MODULE;
#else
# if __cpp_lib_format
#if !defined( VULKAN_HPP_CXX_MODULE )
# if defined( __cpp_lib_format )
# include <format> // std::format
# else
# include <sstream> // std::stringstream
@ -5417,6 +5417,7 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA : return "PhysicalDeviceImageAlignmentControlFeaturesMESA";
case StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA : return "PhysicalDeviceImageAlignmentControlPropertiesMESA";
case StructureType::eImageAlignmentControlCreateInfoMESA : return "ImageAlignmentControlCreateInfoMESA";
case StructureType::ePhysicalDeviceShaderFmaFeaturesKHR : return "PhysicalDeviceShaderFmaFeaturesKHR";
case StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT : return "PhysicalDeviceDepthClampControlFeaturesEXT";
case StructureType::ePipelineViewportDepthClampControlCreateInfoEXT : return "PipelineViewportDepthClampControlCreateInfoEXT";
case StructureType::ePhysicalDeviceMaintenance9FeaturesKHR : return "PhysicalDeviceMaintenance9FeaturesKHR";

47
registry/base_generator.py
View file

@ -9,7 +9,7 @@ import os
import tempfile
import copy
from vulkan_object import (VulkanObject,
Extension, Version, Deprecate, Handle, Param, Queues, CommandScope, Command,
Extension, Version, Deprecate, Handle, Param, CommandScope, Command,
EnumField, Enum, Flag, Bitmask, ExternSync, Flags, Member, Struct,
Constant, FormatComponent, FormatPlane, Format, FeatureRequirement,
SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline,
@ -63,29 +63,6 @@ def externSyncGet(elem):
return (ExternSync.SUBTYPE_MAYBE, value.removeprefix('maybe:'))
return (ExternSync.SUBTYPE, value)
def getQueues(elem) -> Queues:
queuemap = {
'VK_QUEUE_COMPUTE_BIT': Queues.COMPUTE,
'VK_QUEUE_DATA_GRAPH_BIT_ARM': Queues.DATA_GRAPH,
'VK_QUEUE_GRAPHICS_BIT': Queues.GRAPHICS,
'VK_QUEUE_OPTICAL_FLOW_BIT_NV': Queues.OPTICAL_FLOW,
'VK_QUEUE_PROTECTED_BIT': Queues.PROTECTED,
'VK_QUEUE_SPARSE_BINDING_BIT': Queues.SPARSE_BINDING,
'VK_QUEUE_TRANSFER_BIT': Queues.TRANSFER,
'VK_QUEUE_VIDEO_DECODE_BIT_KHR': Queues.DECODE,
'VK_QUEUE_VIDEO_ENCODE_BIT_KHR': Queues.ENCODE,
}
queues = 0
queues_list = splitIfGet(elem, 'queues')
for queue in queues_list:
if queue in queuemap:
queues |= queuemap[queue]
return queues
# Shared object used by Sync elements that do not have ones
maxSyncSupport = SyncSupport(None, None, True)
maxSyncEquivalent = SyncEquivalent(None, None, True)
@ -241,17 +218,6 @@ class BaseGenerator(OutputGenerator):
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'
self.vk.queueBits[Queues.DATA_GRAPH] = 'VK_QUEUE_DATA_GRAPH_BIT_ARM'
# If the video.xml path is provided then we need to load and parse it using
# the private video std generator
if genOpts.videoXmlPath is not None:
@ -400,6 +366,7 @@ class BaseGenerator(OutputGenerator):
if structName in self.vk.structs:
struct = self.vk.structs[structName]
struct.extensions.extend([extension.name] if extension.name not in struct.extensions else [])
extension.structs.extend([struct] if struct not in extension.structs 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
@ -619,7 +586,7 @@ class BaseGenerator(OutputGenerator):
instance = interface.get('type') == 'instance'
device = not instance
depends = interface.get('depends')
vendorTag = interface.get('author')
vendorTag = name.split('_')[1]
platform = interface.get('platform')
provisional = boolGet(interface, 'provisional')
promotedto = interface.get('promotedto')
@ -701,7 +668,7 @@ class BaseGenerator(OutputGenerator):
alias = attrib.get('alias')
tasks = splitIfGet(attrib, 'tasks')
queues = getQueues(attrib)
queues = splitIfGet(attrib, 'queues')
allowNoQueues = boolGet(attrib, 'allownoqueues')
successcodes = splitIfGet(attrib, 'successcodes')
errorcodes = splitIfGet(attrib, 'errorcodes')
@ -735,7 +702,7 @@ class BaseGenerator(OutputGenerator):
device = not instance
implicitElem = cmdinfo.elem.find('implicitexternsyncparams')
implicitExternSyncParams = [x.text for x in implicitElem.findall('param')] if implicitElem else []
implicitExternSyncParams = [x.text for x in implicitElem.findall('param')] if implicitElem is not None else []
self.vk.commands[name] = Command(name, alias, protect, [], self.currentVersion,
returnType, params, instance, device,
@ -1018,7 +985,7 @@ class BaseGenerator(OutputGenerator):
support = maxSyncSupport
supportElem = syncElem.find('syncsupport')
if supportElem is not None:
queues = getQueues(supportElem)
queues = splitIfGet(supportElem, 'queues')
stageNames = splitIfGet(supportElem, 'stage')
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if len(stageNames) > 0 else None
support = SyncSupport(queues, stages, False)
@ -1045,7 +1012,7 @@ class BaseGenerator(OutputGenerator):
support = maxSyncSupport
supportElem = syncElem.find('syncsupport')
if supportElem is not None:
queues = getQueues(supportElem)
queues = splitIfGet(supportElem, 'queues')
stageNames = splitIfGet(supportElem, 'stage')
stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if len(stageNames) > 0 else None
support = SyncSupport(queues, stages, False)

822
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

51
registry/vk.xml
View file

@ -183,7 +183,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> 328</type>
#define <name>VK_HEADER_VERSION</name> 329</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
@ -1494,7 +1494,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkExtent3D</type> <name>imageExtent</name><comment>Specified in pixels for both compressed and uncompressed images</comment></member>
</type>
<type category="struct" name="VkStridedDeviceAddressRangeKHR">
<member><type>VkDeviceAddress</type> <name>address</name></member>
<member optional="true"><type>VkDeviceAddress</type> <name>address</name></member>
<member><type>VkDeviceSize</type> <name>size</name></member>
<member><type>VkDeviceSize</type> <name>stride</name></member>
</type>
@ -8617,6 +8617,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max"><type>VkBool32</type> <name>triStripVertexOrderIndependentOfProvokingVertex</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceShaderFmaFeaturesKHR" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>shaderFmaFloat16</name></member>
<member><type>VkBool32</type> <name>shaderFmaFloat32</name></member>
<member><type>VkBool32</type> <name>shaderFmaFloat64</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceRayTracingMotionBlurFeaturesNV" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true" noautovalidity="true"><type>void</type>* <name>pNext</name></member>
@ -22806,6 +22813,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<require>
<enum value="0" name="VK_KHR_EXTENSION_209_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_extension_209&quot;" name="VK_KHR_EXTENSION_209_EXTENSION_NAME"/>
<enum bitpos="9" extends="VkSwapchainCreateFlagBitsKHR" name="VK_SWAPCHAIN_CREATE_RESERVED_9_BIT_EXT"/>
</require>
</extension>
<extension name="VK_INTEL_shader_integer_functions2" number="210" type="device" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" author="INTEL" contact="Ian Romanick @ianromanick" supported="vulkan">
@ -26112,15 +26120,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="nestedCommandBuffer" struct="VkPhysicalDeviceNestedCommandBufferFeaturesEXT"/>
</require>
</extension>
<extension name="VK_ARM_extension_453" number="453" author="Arm" contact="Kevin Petit @kpet" supported="disabled">
<extension name="VK_HUAWEI_extension_453" number="453" author="HUAWEI" contact="Bill Hollings @billhollings" supported="disabled">
<require>
<enum value="0" name="VK_ARM_EXTENSION_453_SPEC_VERSION"/>
<enum value="&quot;VK_ARM_extension_453&quot;" name="VK_ARM_EXTENSION_453_EXTENSION_NAME"/>
<enum bitpos="11" extends="VkQueueFlagBits" name="VK_QUEUE_RESERVED_11_BIT_ARM"/>
<enum bitpos="43" extends="VkPipelineStageFlagBits2" name="VK_PIPELINE_STAGE_2_RESERVED_43_BIT_ARM"/>
<enum bitpos="49" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_49_BIT_ARM"/>
<enum bitpos="50" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_50_BIT_ARM"/>
<enum bitpos="47" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_47_BIT_ARM"/>
<enum value="0" name="VK_HUAWEI_EXTENSION_453_SPEC_VERSION"/>
<enum value="&quot;VK_HUAWEI_extension_453&quot;" name="VK_HUAWEI_EXTENSION_453_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_EXT_external_memory_acquire_unmodified" number="454" type="device" depends="VK_KHR_external_memory,VK_VERSION_1_1" author="EXT" contact="Lina Versace @linyaa-kiwi" supported="vulkan" ratified="vulkan" nofeatures="true">
@ -28309,10 +28312,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="9" extends="VkShaderCreateFlagBitsEXT" name="VK_SHADER_CREATE_RESERVED_9_BIT_EXT"/>
</require>
</extension>
<extension name="VK_EXT_extension_580" number="580" author="EXT" contact="Graeme Leese @gnl21" supported="disabled">
<extension name="VK_KHR_shader_fma" number="580" type="device" author="KHR" contact="Graeme Leese @gnl21" supported="vulkan" ratified="vulkan">
<require>
<enum value="0" name="VK_EXT_EXTENSION_580_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_580&quot;" name="VK_EXT_EXTENSION_580_EXTENSION_NAME"/>
<enum value="1" name="VK_KHR_SHADER_FMA_SPEC_VERSION"/>
<enum value="&quot;VK_KHR_shader_fma&quot;" name="VK_KHR_SHADER_FMA_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR"/>
<type name="VkPhysicalDeviceShaderFmaFeaturesKHR"/>
<feature name="shaderFmaFloat32" struct="VkPhysicalDeviceShaderFmaFeaturesKHR"/>
</require>
</extension>
<extension name="VK_NV_extension_581" number="581" author="NV" contact="Piers Daniell @pdaniell-nv" supported="disabled">
@ -28971,6 +28977,17 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="18" extends="VkShaderCreateFlagBitsEXT" name="VK_SHADER_CREATE_RESERVED_18_BIT_KHR" />
</require>
</extension>
<extension name="VK_ARM_extension_659" number="659" author="Arm" contact="Kevin Petit @kpet" supported="disabled">
<require>
<enum value="0" name="VK_ARM_EXTENSION_659_SPEC_VERSION"/>
<enum value="&quot;VK_ARM_extension_659&quot;" name="VK_ARM_EXTENSION_659_EXTENSION_NAME"/>
<enum bitpos="11" extends="VkQueueFlagBits" name="VK_QUEUE_RESERVED_11_BIT_ARM"/>
<enum bitpos="43" extends="VkPipelineStageFlagBits2" name="VK_PIPELINE_STAGE_2_RESERVED_43_BIT_ARM"/>
<enum bitpos="49" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_49_BIT_ARM"/>
<enum bitpos="50" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_50_BIT_ARM"/>
<enum bitpos="47" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_47_BIT_ARM"/>
</require>
</extension>
</extensions>
<formats>
<format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">
@ -30682,6 +30699,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enable version="VK_VERSION_1_4"/>
<enable extension="VK_KHR_shader_float_controls2"/>
</spirvextension>
<spirvextension name="SPV_KHR_fma">
<enable extension="VK_KHR_shader_fma"/>
</spirvextension>
<spirvextension name="SPV_KHR_quad_control">
<enable extension="VK_KHR_shader_quad_control"/>
</spirvextension>
@ -31314,6 +31334,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<spirvcapability name="UntypedPointersKHR">
<enable struct="VkPhysicalDeviceShaderUntypedPointersFeaturesKHR" feature="shaderUntypedPointers" requires="VK_KHR_shader_untyped_pointers"/>
</spirvcapability>
<spirvcapability name="FMAKHR">
<enable struct="VkPhysicalDeviceShaderFmaFeaturesKHR" feature="shaderFmaFloat16" requires="VK_KHR_shader_fma"/>
<enable struct="VkPhysicalDeviceShaderFmaFeaturesKHR" feature="shaderFmaFloat32" requires="VK_KHR_shader_fma"/>
<enable struct="VkPhysicalDeviceShaderFmaFeaturesKHR" feature="shaderFmaFloat64" requires="VK_KHR_shader_fma"/>
</spirvcapability>
</spirvcapabilities>
<sync comment="Machine readable representation of the synchronization objects and their mappings">
<syncstage name="VK_PIPELINE_STAGE_2_NONE" alias="VK_PIPELINE_STAGE_NONE">

20
registry/vulkan_object.py
View file

@ -41,8 +41,9 @@ class Extension:
# These are here to allow for easy reverse lookups
# To prevent infinite recursion, other classes reference a string back to the Extension class
# Quotes allow us to forward declare the dataclass
handles: list['Handle'] = field(default_factory=list, init=False)
handles: list['Handle'] = field(default_factory=list, init=False)
commands: list['Command'] = field(default_factory=list, init=False)
structs: list['Struct'] = field(default_factory=list, init=False)
enums: list['Enum'] = field(default_factory=list, init=False)
bitmasks: list['Bitmask'] = field(default_factory=list, init=False)
flags: dict[str, list['Flags']] = field(default_factory=dict, init=False)
@ -141,17 +142,6 @@ class Param:
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
DATA_GRAPH = auto() # VK_QUEUE_DATA_GRAPH_BIT_ARM
class CommandScope(Enum):
NONE = auto()
INSIDE = auto()
@ -177,7 +167,7 @@ class Command:
device: bool
tasks: list[str] # ex) [ action, state, synchronization ]
queues: Queues # zero == No Queues found (represents restriction which queue type can be used)
queues: list[str] # ex) [ VK_QUEUE_GRAPHICS_BIT, VK_QUEUE_COMPUTE_BIT ]
allowNoQueues: bool # VK_KHR_maintenance9 allows some calls to be done with zero queues
successCodes: list[str] # ex) [ VK_SUCCESS, VK_INCOMPLETE ]
errorCodes: list[str] # ex) [ VK_ERROR_OUT_OF_HOST_MEMORY ]
@ -422,7 +412,7 @@ class Format:
@dataclass
class SyncSupport:
"""<syncsupport>"""
queues: Queues
queues: list[str] # ex) [ VK_QUEUE_GRAPHICS_BIT, VK_QUEUE_COMPUTE_BIT ]
stages: list[Flag] # VkPipelineStageFlagBits2
max: bool # If this supports max values
@ -581,8 +571,6 @@ class VulkanObject():
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)
# Video codec information from the vk.xml
videoCodecs: dict[str, VideoCodec] = field(default_factory=dict, init=False)