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

Update for Vulkan-Docs 1.4.324

Browse source
This commit is contained in:
Jon Leech 2025-08-01 04:14:14 +01:00 • committed by Jon Leech
parent 37057b4756
commit a1c3885d4e
18 changed files with 4698 additions and 3936 deletions
Download patch file Download diff file Expand all files Collapse all files

31
include/vulkan/vulkan.cppm
View file

@ -875,6 +875,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::AntiLagModeAMD;
using VULKAN_HPP_NAMESPACE::AntiLagStageAMD;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
using VULKAN_HPP_NAMESPACE::CompressedTriangleFormatAMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_shader_object ===
using VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT;
using VULKAN_HPP_NAMESPACE::ShaderCreateFlagBitsEXT;
@ -2533,6 +2538,14 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::AMDAntiLagExtensionName;
using VULKAN_HPP_NAMESPACE::AMDAntiLagSpecVersion;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
using VULKAN_HPP_NAMESPACE::AMDXDenseGeometryFormatExtensionName;
using VULKAN_HPP_NAMESPACE::AMDXDenseGeometryFormatSpecVersion;
using VULKAN_HPP_NAMESPACE::CompressedTriangleFormatDgf1ByteAlignmentAMDX;
using VULKAN_HPP_NAMESPACE::CompressedTriangleFormatDgf1ByteStrideAMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_present_id2 ===
using VULKAN_HPP_NAMESPACE::KHRPresentId2ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRPresentId2SpecVersion;
@ -4654,6 +4667,12 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
using VULKAN_HPP_NAMESPACE::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_present_id2 ===
using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR;
using VULKAN_HPP_NAMESPACE::PresentId2KHR;
@ -8360,6 +8379,14 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD>;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX>;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_present_id2 ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR>;
@ -8944,9 +8971,9 @@ export namespace std
//=== VK_KHR_maintenance8 ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR>;
//=== VK_MESA_image_alignment_control ===
template <>

135
include/vulkan/vulkan.hpp
View file

@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif
#endif
static_assert( VK_HEADER_VERSION == 323, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 324, "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)
@ -7243,6 +7243,36 @@ namespace VULKAN_HPP_NAMESPACE
{
return std::tuple<Result &, T &>( result, value );
}
// std::expected-look alike
bool has_value() const VULKAN_HPP_NOEXCEPT
{
return result == vk::Result::eSuccess;
}
T const * operator->() const VULKAN_HPP_NOEXCEPT
{
assert( has_value() );
return &value;
}
T * operator->() VULKAN_HPP_NOEXCEPT
{
assert( has_value() );
return &value;
}
T const & operator*() const VULKAN_HPP_NOEXCEPT
{
assert( has_value() );
return value;
}
T & operator*() VULKAN_HPP_NOEXCEPT
{
assert( has_value() );
return value;
}
};
#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
@ -7330,8 +7360,9 @@ namespace VULKAN_HPP_NAMESPACE
namespace detail
{
template <typename T>
void ignore( T const & ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR bool ignore( T const & ) VULKAN_HPP_NOEXCEPT
{
return true;
}
VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType( Result result )
@ -7470,6 +7501,12 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_module_identifier ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxShaderModuleIdentifierSizeEXT = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t CompressedTriangleFormatDgf1ByteAlignmentAMDX = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t CompressedTriangleFormatDgf1ByteStrideAMDX = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_pipeline_binary ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPipelineBinaryKeySizeKHR = VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR;
@ -9023,6 +9060,12 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagExtensionName = VK_AMD_ANTI_LAG_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagSpecVersion = VK_AMD_ANTI_LAG_SPEC_VERSION;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
VULKAN_HPP_CONSTEXPR_INLINE auto AMDXDenseGeometryFormatExtensionName = VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDXDenseGeometryFormatSpecVersion = VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_present_id2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2ExtensionName = VK_KHR_PRESENT_ID_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2SpecVersion = VK_KHR_PRESENT_ID_2_SPEC_VERSION;
@ -15745,6 +15788,16 @@ namespace VULKAN_HPP_NAMESPACE
value = true
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct StructExtends<AccelerationStructureTrianglesOpacityMicromapEXT, AccelerationStructureDenseGeometryFormatTrianglesDataAMDX>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_displacement_micromap ===
@ -16779,6 +16832,36 @@ namespace VULKAN_HPP_NAMESPACE
};
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
template <>
struct StructExtends<PhysicalDeviceDenseGeometryFormatFeaturesAMDX, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceDenseGeometryFormatFeaturesAMDX, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<AccelerationStructureDenseGeometryFormatTrianglesDataAMDX, AccelerationStructureGeometryKHR>
{
enum
{
value = true
};
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_present_id2 ===
template <>
struct StructExtends<SurfaceCapabilitiesPresentId2KHR, SurfaceCapabilities2KHR>
@ -18681,24 +18764,6 @@ namespace VULKAN_HPP_NAMESPACE
};
//=== VK_KHR_maintenance8 ===
template <>
struct StructExtends<PhysicalDeviceMaintenance8FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance8FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<MemoryBarrierAccessFlags3KHR, SubpassDependency2>
{
@ -18726,6 +18791,24 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance8FeaturesKHR, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceMaintenance8FeaturesKHR, DeviceCreateInfo>
{
enum
{
value = true
};
};
//=== VK_MESA_image_alignment_control ===
template <>
struct StructExtends<PhysicalDeviceImageAlignmentControlFeaturesMESA, PhysicalDeviceFeatures2>
@ -19250,6 +19333,12 @@ namespace VULKAN_HPP_NAMESPACE
{
m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL );
}
// modern versions of macOS don't search /usr/local/lib automatically contrary to what man dlopen says
// Vulkan SDK uses this as the system-wide installation location, so we're going to fallback to this if all else fails
if ( !m_library && ( getenv( "DYLD_FALLBACK_LIBRARY_PATH" ) == NULL ) )
{
m_library = dlopen( "/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
}
if ( !m_library )
{
m_library = dlopen( "libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL );
@ -19264,12 +19353,6 @@ namespace VULKAN_HPP_NAMESPACE
{
m_library = dlopen( "MoltenVK.framework/MoltenVK", RTLD_NOW | RTLD_LOCAL );
}
// modern versions of macOS don't search /usr/local/lib automatically contrary to what man dlopen says
// Vulkan SDK uses this as the system-wide installation location, so we're going to fallback to this if all else fails
if ( !m_library && ( getenv( "DYLD_FALLBACK_LIBRARY_PATH" ) == NULL ) )
{
m_library = dlopen( "/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
}
# elif defined( __unix__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
if ( !m_library )

31
include/vulkan/vulkan_beta.h
View file

@ -337,6 +337,37 @@ typedef struct VkAccelerationStructureTrianglesDisplacementMicromapNV {
} VkAccelerationStructureTrianglesDisplacementMicromapNV;
// VK_AMDX_dense_geometry_format is a preprocessor guard. Do not pass it to API calls.
#define VK_AMDX_dense_geometry_format 1
#define VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION 1
#define VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME "VK_AMDX_dense_geometry_format"
#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX 128U
#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX 128U
typedef enum VkCompressedTriangleFormatAMDX {
VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX = 0,
VK_COMPRESSED_TRIANGLE_FORMAT_MAX_ENUM_AMDX = 0x7FFFFFFF
} VkCompressedTriangleFormatAMDX;
typedef struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX {
VkStructureType sType;
void* pNext;
VkBool32 denseGeometryFormat;
} VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX;
typedef struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX {
VkStructureType sType;
const void* pNext;
VkDeviceOrHostAddressConstKHR compressedData;
VkDeviceSize dataSize;
uint32_t numTriangles;
uint32_t numVertices;
uint32_t maxPrimitiveIndex;
uint32_t maxGeometryIndex;
VkCompressedTriangleFormatAMDX format;
} VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
#ifdef __cplusplus
}
#endif

26
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 323
#define VK_HEADER_VERSION 324
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1086,6 +1086,12 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD = 1000476000,
VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD = 1000476001,
VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD = 1000476002,
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX = 1000478000,
#endif
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX = 1000478001,
#endif
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR = 1000479000,
VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR = 1000479001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR = 1000479002,
@ -8100,6 +8106,9 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL;
#ifdef VK_ENABLE_BETA_EXTENSIONS
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX = 0x200000000ULL;
#endif
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM = 0x20000000ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM = 0x08000000ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ULL;
@ -13616,12 +13625,6 @@ typedef VkFlags64 VkAccessFlags3KHR;
typedef VkFlags64 VkAccessFlagBits3KHR;
static const VkAccessFlagBits3KHR VK_ACCESS_3_NONE_KHR = 0ULL;
typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 maintenance8;
} VkPhysicalDeviceMaintenance8FeaturesKHR;
typedef struct VkMemoryBarrierAccessFlags3KHR {
VkStructureType sType;
const void* pNext;
@ -13629,6 +13632,12 @@ typedef struct VkMemoryBarrierAccessFlags3KHR {
VkAccessFlags3KHR dstAccessMask3;
} VkMemoryBarrierAccessFlags3KHR;
typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR {
VkStructureType sType;
void* pNext;
VkBool32 maintenance8;
} VkPhysicalDeviceMaintenance8FeaturesKHR;
// VK_KHR_maintenance9 is a preprocessor guard. Do not pass it to API calls.
@ -15728,6 +15737,9 @@ typedef enum VkGeometryTypeKHR {
VK_GEOMETRY_TYPE_INSTANCES_KHR = 2,
VK_GEOMETRY_TYPE_SPHERES_NV = 1000429004,
VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV = 1000429005,
#ifdef VK_ENABLE_BETA_EXTENSIONS
VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX = 1000478000,
#endif
VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR,
VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF

42
include/vulkan/vulkan_enums.hpp
View file

@ -1429,9 +1429,13 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceExternalFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID,
eAndroidHardwareBufferFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID,
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
ePhysicalDeviceAntiLagFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD,
eAntiLagDataAMD = VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD,
eAntiLagPresentationInfoAMD = VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD,
ePhysicalDeviceAntiLagFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD,
eAntiLagDataAMD = VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD,
eAntiLagPresentationInfoAMD = VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD,
#if defined( VK_ENABLE_BETA_EXTENSIONS )
ePhysicalDeviceDenseGeometryFormatFeaturesAMDX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX,
eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eSurfaceCapabilitiesPresentId2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR,
ePresentId2KHR = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR,
ePhysicalDevicePresentId2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR,
@ -5281,9 +5285,12 @@ namespace VULKAN_HPP_NAMESPACE
ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT,
eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT,
eMicromapStorageEXT = VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT,
eDataGraphForeignDescriptorARM = VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM,
eTileMemoryQCOM = VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM,
ePreprocessBufferEXT = VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eCompressedDataDgf1AMDX = VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
eDataGraphForeignDescriptorARM = VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM,
eTileMemoryQCOM = VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM,
ePreprocessBufferEXT = VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT
};
using BufferUsageFlagBits2KHR = BufferUsageFlagBits2;
@ -5310,8 +5317,11 @@ namespace VULKAN_HPP_NAMESPACE
BufferUsageFlagBits2::eVideoEncodeDstKHR | BufferUsageFlagBits2::eVideoEncodeSrcKHR | BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR |
BufferUsageFlagBits2::eAccelerationStructureStorageKHR | BufferUsageFlagBits2::eSamplerDescriptorBufferEXT |
BufferUsageFlagBits2::eResourceDescriptorBufferEXT | BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT |
BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT | BufferUsageFlagBits2::eMicromapStorageEXT | BufferUsageFlagBits2::eDataGraphForeignDescriptorARM |
BufferUsageFlagBits2::eTileMemoryQCOM | BufferUsageFlagBits2::ePreprocessBufferEXT;
BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT | BufferUsageFlagBits2::eMicromapStorageEXT
#if defined( VK_ENABLE_BETA_EXTENSIONS )
| BufferUsageFlagBits2::eCompressedDataDgf1AMDX
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
| BufferUsageFlagBits2::eDataGraphForeignDescriptorARM | BufferUsageFlagBits2::eTileMemoryQCOM | BufferUsageFlagBits2::ePreprocessBufferEXT;
};
// wrapper class for enum VkPipelineRobustnessBufferBehavior, see
@ -6907,7 +6917,10 @@ namespace VULKAN_HPP_NAMESPACE
eAabbs = VK_GEOMETRY_TYPE_AABBS_KHR,
eInstances = VK_GEOMETRY_TYPE_INSTANCES_KHR,
eSpheresNV = VK_GEOMETRY_TYPE_SPHERES_NV,
eLinearSweptSpheresNV = VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV
eLinearSweptSpheresNV = VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV,
#if defined( VK_ENABLE_BETA_EXTENSIONS )
eDenseGeometryFormatTrianglesAMDX = VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
};
using GeometryTypeNV = GeometryTypeKHR;
@ -8349,6 +8362,17 @@ namespace VULKAN_HPP_NAMESPACE
ePresent = VK_ANTI_LAG_STAGE_PRESENT_AMD
};
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
// wrapper class for enum VkCompressedTriangleFormatAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompressedTriangleFormatAMDX.html
enum class CompressedTriangleFormatAMDX
{
eDgf1 = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_shader_object ===
// wrapper class for enum VkShaderCreateFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateFlagBitsEXT.html

49
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -411,6 +411,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
"VK_KHR_maintenance5",
"VK_AMD_anti_lag",
#if defined( VK_ENABLE_BETA_EXTENSIONS )
"VK_AMDX_dense_geometry_format",
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
"VK_KHR_present_id2",
"VK_KHR_present_wait2",
"VK_KHR_ray_tracing_position_fetch",
@ -2286,6 +2289,18 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_dynamic_rendering",
} } },
{ "VK_VERSION_1_3", { {} } } } },
#if defined( VK_ENABLE_BETA_EXTENSIONS )
{ "VK_AMDX_dense_geometry_format",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_acceleration_structure",
"VK_KHR_maintenance5",
} } },
{ "VK_VERSION_1_4",
{ {
"VK_KHR_acceleration_structure",
} } } } },
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
{ "VK_KHR_present_id2",
{ { "VK_VERSION_1_0",
{ {
@ -3601,21 +3616,25 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
|| ( extension == "VK_ANDROID_external_format_resolve" )
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|| ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) || ( extension == "VK_KHR_present_id2" ) ||
( extension == "VK_KHR_present_wait2" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) || ( extension == "VK_EXT_shader_object" ) ||
( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) || ( extension == "VK_SEC_amigo_profiling" ) ||
( extension == "VK_KHR_swapchain_maintenance1" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_cooperative_vector" ) ||
( extension == "VK_NV_extended_sparse_address_space" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) ||
( extension == "VK_EXT_legacy_vertex_attributes" ) || ( extension == "VK_ARM_shader_core_builtins" ) ||
( extension == "VK_EXT_pipeline_library_group_handles" ) || ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) ||
( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_ARM_data_graph" ) ||
( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_compute_shader_derivatives" ) ||
( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) || ( extension == "VK_KHR_video_decode_vp9" ) ||
( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) ||
( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) ||
( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) ||
( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_unified_image_layouts" ) || ( extension == "VK_KHR_shader_float_controls2" )
|| ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_AMDX_dense_geometry_format" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|| ( extension == "VK_KHR_present_id2" ) || ( extension == "VK_KHR_present_wait2" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) ||
( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) ||
( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_KHR_swapchain_maintenance1" ) ||
( extension == "VK_QCOM_multiview_per_view_viewports" ) || ( extension == "VK_NV_ray_tracing_invocation_reorder" ) ||
( extension == "VK_NV_cooperative_vector" ) || ( extension == "VK_NV_extended_sparse_address_space" ) ||
( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) ||
( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) ||
( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_ARM_data_graph" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
( extension == "VK_KHR_compute_shader_derivatives" ) || ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) ||
( extension == "VK_KHR_video_decode_vp9" ) || ( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) ||
( extension == "VK_QCOM_image_processing2" ) || ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) ||
( extension == "VK_QCOM_filter_cubic_clamp" ) || ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) ||
( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
( extension == "VK_KHR_unified_image_layouts" ) || ( extension == "VK_KHR_shader_float_controls2" )
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
|| ( extension == "VK_QNX_external_memory_screen_buffer" )
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/

8
include/vulkan/vulkan_handles.hpp
View file

@ -1740,6 +1740,12 @@ namespace VULKAN_HPP_NAMESPACE
struct AntiLagDataAMD;
struct AntiLagPresentationInfoAMD;
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX;
struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_present_id2 ===
struct SurfaceCapabilitiesPresentId2KHR;
struct PresentId2KHR;
@ -2097,8 +2103,8 @@ namespace VULKAN_HPP_NAMESPACE
struct WriteIndirectExecutionSetShaderEXT;
//=== VK_KHR_maintenance8 ===
struct PhysicalDeviceMaintenance8FeaturesKHR;
struct MemoryBarrierAccessFlags3KHR;
struct PhysicalDeviceMaintenance8FeaturesKHR;
//=== VK_MESA_image_alignment_control ===
struct PhysicalDeviceImageAlignmentControlFeaturesMESA;

24
include/vulkan/vulkan_hash.hpp
View file

@ -4393,14 +4393,6 @@ namespace std
VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags );
VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount );
VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos );
VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount );
for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i )
{
for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p )
{
VULKAN_HPP_HASH_COMBINE( seed, *p );
}
}
VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount );
for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i )
{
@ -9492,6 +9484,22 @@ namespace std
}
};
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & physicalDeviceDenseGeometryFormatFeaturesAMDX ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.denseGeometryFormat );
return seed;
}
};
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT>
{

23
include/vulkan/vulkan_hpp_macros.hpp
View file

@ -158,6 +158,11 @@
# else
# define VULKAN_HPP_CONSTEXPR_14
# endif
# if 201603 <= __cpp_constexpr
# define VULKAN_HPP_CONSTEXPR_17 constexpr
# else
# define VULKAN_HPP_CONSTEXPR_17
# endif
# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) )
# define VULKAN_HPP_CONSTEXPR_20 constexpr
# else
@ -304,23 +309,9 @@ namespace VULKAN_HPP_NAMESPACE
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
#endif
#if !defined( VULKAN_HPP_EXPECTED ) && ( 23 <= VULKAN_HPP_CPP_VERSION ) && defined( __cpp_lib_expected )
# if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
# include <expected>
# endif
# define VULKAN_HPP_EXPECTED std::expected
# define VULKAN_HPP_UNEXPECTED std::unexpected
#endif
#if !defined( VULKAN_HPP_RAII_NAMESPACE )
# define VULKAN_HPP_RAII_NAMESPACE raii
#endif
#if defined( VULKAN_HPP_NO_EXCEPTIONS ) && defined( VULKAN_HPP_EXPECTED )
# define VULKAN_HPP_RAII_NO_EXCEPTIONS
# define VULKAN_HPP_RAII_CREATE_NOEXCEPT noexcept
#else
# define VULKAN_HPP_RAII_CREATE_NOEXCEPT
# define VULKAN_HPP_RAII_NAMESPACE raii
# define VULKAN_HPP_RAII_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE )
#endif
#endif

4590
include/vulkan/vulkan_raii.hpp
View file

File diff suppressed because it is too large Load diff

32
include/vulkan/vulkan_static_assertions.hpp
View file

@ -7136,6 +7136,26 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::AntiLagP
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD>::value,
"AntiLagPresentationInfoAMD is not nothrow_move_constructible!" );
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX ) ==
sizeof( VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX>::value,
"PhysicalDeviceDenseGeometryFormatFeaturesAMDX is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX ) ==
sizeof( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX>::value,
"AccelerationStructureDenseGeometryFormatTrianglesDataAMDX is not nothrow_move_constructible!" );
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_KHR_present_id2 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR ) == sizeof( VkSurfaceCapabilitiesPresentId2KHR ),
@ -8871,6 +8891,12 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
//=== VK_KHR_maintenance8 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR ) == sizeof( VkMemoryBarrierAccessFlags3KHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>::value,
"MemoryBarrierAccessFlags3KHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance8FeaturesKHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR>::value,
@ -8878,12 +8904,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR>::value,
"PhysicalDeviceMaintenance8FeaturesKHR is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR ) == sizeof( VkMemoryBarrierAccessFlags3KHR ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR>::value,
"MemoryBarrierAccessFlags3KHR is not nothrow_move_constructible!" );
//=== VK_MESA_image_alignment_control ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA ) ==

392
include/vulkan/vulkan_structs.hpp
View file

@ -2357,6 +2357,167 @@ namespace VULKAN_HPP_NAMESPACE
using Type = AccelerationStructureCreateInfoNV;
};
#if defined( VK_ENABLE_BETA_EXTENSIONS )
// wrapper struct for struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX.html
struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX
{
using NativeType = VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR_14
AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( DeviceOrHostAddressConstKHR compressedData_ = {},
DeviceSize dataSize_ = {},
uint32_t numTriangles_ = {},
uint32_t numVertices_ = {},
uint32_t maxPrimitiveIndex_ = {},
uint32_t maxGeometryIndex_ = {},
CompressedTriangleFormatAMDX format_ = CompressedTriangleFormatAMDX::eDgf1,
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, compressedData{ compressedData_ }
, dataSize{ dataSize_ }
, numTriangles{ numTriangles_ }
, numVertices{ numVertices_ }
, maxPrimitiveIndex{ maxPrimitiveIndex_ }
, maxGeometryIndex{ maxGeometryIndex_ }
, format{ format_ }
{
}
VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs )
VULKAN_HPP_NOEXCEPT = default;
AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT
: AccelerationStructureDenseGeometryFormatTrianglesDataAMDX(
*reinterpret_cast<AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *>( &rhs ) )
{
}
AccelerationStructureDenseGeometryFormatTrianglesDataAMDX &
operator=( AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
AccelerationStructureDenseGeometryFormatTrianglesDataAMDX &
operator=( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX &
setCompressedData( DeviceOrHostAddressConstKHR const & compressedData_ ) VULKAN_HPP_NOEXCEPT
{
compressedData = compressedData_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setDataSize( DeviceSize dataSize_ ) VULKAN_HPP_NOEXCEPT
{
dataSize = dataSize_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setNumTriangles( uint32_t numTriangles_ ) VULKAN_HPP_NOEXCEPT
{
numTriangles = numTriangles_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setNumVertices( uint32_t numVertices_ ) VULKAN_HPP_NOEXCEPT
{
numVertices = numVertices_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setMaxPrimitiveIndex( uint32_t maxPrimitiveIndex_ ) VULKAN_HPP_NOEXCEPT
{
maxPrimitiveIndex = maxPrimitiveIndex_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setMaxGeometryIndex( uint32_t maxGeometryIndex_ ) VULKAN_HPP_NOEXCEPT
{
maxGeometryIndex = maxGeometryIndex_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setFormat( CompressedTriangleFormatAMDX format_ ) VULKAN_HPP_NOEXCEPT
{
format = format_;
return *this;
}
# endif /*VULKAN_HPP_NO_SETTERS*/
operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *>( this );
}
operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *>( this );
}
operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *>( this );
}
operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<StructureType const &,
const void * const &,
DeviceOrHostAddressConstKHR const &,
DeviceSize const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
uint32_t const &,
CompressedTriangleFormatAMDX const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, compressedData, dataSize, numTriangles, numVertices, maxPrimitiveIndex, maxGeometryIndex, format );
}
# endif
public:
StructureType sType = StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
const void * pNext = {};
DeviceOrHostAddressConstKHR compressedData = {};
DeviceSize dataSize = {};
uint32_t numTriangles = {};
uint32_t numVertices = {};
uint32_t maxPrimitiveIndex = {};
uint32_t maxGeometryIndex = {};
CompressedTriangleFormatAMDX format = CompressedTriangleFormatAMDX::eDgf1;
};
template <>
struct CppType<StructureType, StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX>
{
using Type = AccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
// wrapper struct for struct VkAccelerationStructureDeviceAddressInfoKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html
struct AccelerationStructureDeviceAddressInfoKHR
@ -35995,28 +36156,48 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceCreateInfo;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR DeviceCreateInfo( DeviceCreateFlags flags_ = {},
uint32_t queueCreateInfoCount_ = {},
const DeviceQueueCreateInfo * pQueueCreateInfos_ = {},
uint32_t enabledLayerCount_ = {},
const char * const * ppEnabledLayerNames_ = {},
uint32_t enabledExtensionCount_ = {},
const char * const * ppEnabledExtensionNames_ = {},
const PhysicalDeviceFeatures * pEnabledFeatures_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
# if defined( _MSC_VER )
// no need to ignore this warning with MSVC
# elif defined( __clang__ )
// no need to ignore this warning with clang
# elif defined( __GNUC__ )
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# else
// unknown compiler... just ignore the warnings for yourselves ;)
# endif
VULKAN_HPP_CONSTEXPR_17 DeviceCreateInfo( DeviceCreateFlags flags_ = {},
uint32_t queueCreateInfoCount_ = {},
const DeviceQueueCreateInfo * pQueueCreateInfos_ = {},
uint32_t enabledLayerCount_ = {},
const char * const * ppEnabledLayerNames_ = {},
uint32_t enabledExtensionCount_ = {},
const char * const * ppEnabledExtensionNames_ = {},
const PhysicalDeviceFeatures * pEnabledFeatures_ = {},
const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, flags{ flags_ }
, queueCreateInfoCount{ queueCreateInfoCount_ }
, pQueueCreateInfos{ pQueueCreateInfos_ }
, enabledLayerCount{ enabledLayerCount_ }
, ppEnabledLayerNames{ ppEnabledLayerNames_ }
, enabledExtensionCount{ enabledExtensionCount_ }
, ppEnabledExtensionNames{ ppEnabledExtensionNames_ }
, pEnabledFeatures{ pEnabledFeatures_ }
{
detail::ignore( enabledLayerCount_ );
detail::ignore( ppEnabledLayerNames_ );
}
VULKAN_HPP_CONSTEXPR DeviceCreateInfo( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VULKAN_HPP_CONSTEXPR_17 DeviceCreateInfo( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
: pNext{ rhs.pNext }
, flags{ rhs.flags }
, queueCreateInfoCount{ rhs.queueCreateInfoCount }
, pQueueCreateInfos{ rhs.pQueueCreateInfos }
, enabledExtensionCount{ rhs.enabledExtensionCount }
, ppEnabledExtensionNames{ rhs.ppEnabledExtensionNames }
, pEnabledFeatures{ rhs.pEnabledFeatures }
{
}
DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceCreateInfo( *reinterpret_cast<DeviceCreateInfo const *>( &rhs ) ) {}
@ -36031,21 +36212,49 @@ namespace VULKAN_HPP_NAMESPACE
, flags( flags_ )
, queueCreateInfoCount( static_cast<uint32_t>( queueCreateInfos_.size() ) )
, pQueueCreateInfos( queueCreateInfos_.data() )
, enabledLayerCount( static_cast<uint32_t>( pEnabledLayerNames_.size() ) )
, ppEnabledLayerNames( pEnabledLayerNames_.data() )
, enabledExtensionCount( static_cast<uint32_t>( pEnabledExtensionNames_.size() ) )
, ppEnabledExtensionNames( pEnabledExtensionNames_.data() )
, pEnabledFeatures( pEnabledFeatures_ )
{
detail::ignore( pEnabledLayerNames_ );
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
DeviceCreateInfo & operator=( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# if defined( _MSC_VER )
// no need to ignore this warning with MSVC
# elif defined( __clang__ )
// no need to ignore this warning with clang
# elif defined( __GNUC__ )
# pragma GCC diagnostic pop
# else
// unknown compiler... just ignore the warnings for yourselves ;)
# endif
DeviceCreateInfo & operator=( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
if ( this != &rhs )
{
pNext = rhs.pNext;
flags = rhs.flags;
queueCreateInfoCount = rhs.queueCreateInfoCount;
pQueueCreateInfos = rhs.pQueueCreateInfos;
enabledExtensionCount = rhs.enabledExtensionCount;
ppEnabledExtensionNames = rhs.ppEnabledExtensionNames;
pEnabledFeatures = rhs.pEnabledFeatures;
}
return *this;
}
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
DeviceCreateInfo & operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<DeviceCreateInfo const *>( &rhs );
pNext = rhs.pNext;
flags = static_cast<DeviceCreateFlags>( rhs.flags );
queueCreateInfoCount = rhs.queueCreateInfoCount;
pQueueCreateInfos = reinterpret_cast<const DeviceQueueCreateInfo *>( rhs.pQueueCreateInfos );
enabledExtensionCount = rhs.enabledExtensionCount;
ppEnabledExtensionNames = rhs.ppEnabledExtensionNames;
pEnabledFeatures = reinterpret_cast<const PhysicalDeviceFeatures *>( rhs.pEnabledFeatures );
return *this;
}
@ -36083,23 +36292,24 @@ namespace VULKAN_HPP_NAMESPACE
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_DEPRECATED( "ignored" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) VULKAN_HPP_NOEXCEPT
{
enabledLayerCount = enabledLayerCount_;
detail::ignore( enabledLayerCount_ );
return *this;
}
VULKAN_HPP_DEPRECATED( "ignored" )
VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT
{
ppEnabledLayerNames = ppEnabledLayerNames_;
detail::ignore( ppEnabledLayerNames_ );
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
VULKAN_HPP_DEPRECATED( "ignored" )
DeviceCreateInfo & setPEnabledLayerNames( ArrayProxyNoTemporaries<const char * const> const & pEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT
{
enabledLayerCount = static_cast<uint32_t>( pEnabledLayerNames_.size() );
ppEnabledLayerNames = pEnabledLayerNames_.data();
detail::ignore( pEnabledLayerNames_ );
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -36195,14 +36405,6 @@ namespace VULKAN_HPP_NAMESPACE
return cmp;
if ( auto cmp = pQueueCreateInfos <=> rhs.pQueueCreateInfos; cmp != 0 )
return cmp;
if ( auto cmp = enabledLayerCount <=> rhs.enabledLayerCount; cmp != 0 )
return cmp;
for ( size_t i = 0; i < enabledLayerCount; ++i )
{
if ( ppEnabledLayerNames[i] != rhs.ppEnabledLayerNames[i] )
if ( auto cmp = strcmp( ppEnabledLayerNames[i], rhs.ppEnabledLayerNames[i] ); cmp != 0 )
return cmp < 0 ? std::strong_ordering::less : std::strong_ordering::greater;
}
if ( auto cmp = enabledExtensionCount <=> rhs.enabledExtensionCount; cmp != 0 )
return cmp;
for ( size_t i = 0; i < enabledExtensionCount; ++i )
@ -36221,12 +36423,7 @@ namespace VULKAN_HPP_NAMESPACE
bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueCreateInfoCount == rhs.queueCreateInfoCount ) &&
( pQueueCreateInfos == rhs.pQueueCreateInfos ) && ( enabledLayerCount == rhs.enabledLayerCount ) &&
std::equal( ppEnabledLayerNames,
ppEnabledLayerNames + enabledLayerCount,
rhs.ppEnabledLayerNames,
[]( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ) &&
( enabledExtensionCount == rhs.enabledExtensionCount ) &&
( pQueueCreateInfos == rhs.pQueueCreateInfos ) && ( enabledExtensionCount == rhs.enabledExtensionCount ) &&
std::equal( ppEnabledExtensionNames,
ppEnabledExtensionNames + enabledExtensionCount,
rhs.ppEnabledExtensionNames,
@ -36240,13 +36437,13 @@ namespace VULKAN_HPP_NAMESPACE
}
public:
StructureType sType = StructureType::eDeviceCreateInfo;
const void * pNext = {};
DeviceCreateFlags flags = {};
uint32_t queueCreateInfoCount = {};
const DeviceQueueCreateInfo * pQueueCreateInfos = {};
uint32_t enabledLayerCount = {};
const char * const * ppEnabledLayerNames = {};
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 = {};
@ -78730,6 +78927,117 @@ namespace VULKAN_HPP_NAMESPACE
using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
};
#if defined( VK_ENABLE_BETA_EXTENSIONS )
// wrapper struct for struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX.html
struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX
{
using NativeType = VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX;
# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceDenseGeometryFormatFeaturesAMDX( Bool32 denseGeometryFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, denseGeometryFormat{ denseGeometryFormat_ }
{
}
VULKAN_HPP_CONSTEXPR
PhysicalDeviceDenseGeometryFormatFeaturesAMDX( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceDenseGeometryFormatFeaturesAMDX( VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceDenseGeometryFormatFeaturesAMDX( *reinterpret_cast<PhysicalDeviceDenseGeometryFormatFeaturesAMDX const *>( &rhs ) )
{
}
PhysicalDeviceDenseGeometryFormatFeaturesAMDX & operator=( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default;
# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceDenseGeometryFormatFeaturesAMDX & operator=( VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<PhysicalDeviceDenseGeometryFormatFeaturesAMDX const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX & setDenseGeometryFormat( Bool32 denseGeometryFormat_ ) VULKAN_HPP_NOEXCEPT
{
denseGeometryFormat = denseGeometryFormat_;
return *this;
}
# endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *>( this );
}
operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *>( this );
}
operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *>( this );
}
operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *>( this );
}
# if defined( VULKAN_HPP_USE_REFLECT )
# if 14 <= VULKAN_HPP_CPP_VERSION
auto
# else
std::tuple<StructureType const &, void * const &, Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, denseGeometryFormat );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & ) const = default;
# else
bool operator==( PhysicalDeviceDenseGeometryFormatFeaturesAMDX 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 ) && ( denseGeometryFormat == rhs.denseGeometryFormat );
# endif
}
bool operator!=( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
StructureType sType = StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX;
void * pNext = {};
Bool32 denseGeometryFormat = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX>
{
using Type = PhysicalDeviceDenseGeometryFormatFeaturesAMDX;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
// wrapper struct for struct VkPhysicalDeviceDepthBiasControlFeaturesEXT, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthBiasControlFeaturesEXT.html
struct PhysicalDeviceDepthBiasControlFeaturesEXT

43
include/vulkan/vulkan_to_string.hpp
View file

@ -2159,6 +2159,10 @@ namespace VULKAN_HPP_NAMESPACE
result += " MicromapBuildInputReadOnlyEXT |";
if ( value & BufferUsageFlagBits2::eMicromapStorageEXT )
result += " MicromapStorageEXT |";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( value & BufferUsageFlagBits2::eCompressedDataDgf1AMDX )
result += " CompressedDataDgf1AMDX |";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & BufferUsageFlagBits2::eDataGraphForeignDescriptorARM )
result += " DataGraphForeignDescriptorARM |";
if ( value & BufferUsageFlagBits2::eTileMemoryQCOM )
@ -5117,9 +5121,13 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID: return "PhysicalDeviceExternalFormatResolvePropertiesANDROID";
case StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID : return "AndroidHardwareBufferFormatResolvePropertiesANDROID";
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
case StructureType::ePhysicalDeviceAntiLagFeaturesAMD : return "PhysicalDeviceAntiLagFeaturesAMD";
case StructureType::eAntiLagDataAMD : return "AntiLagDataAMD";
case StructureType::eAntiLagPresentationInfoAMD : return "AntiLagPresentationInfoAMD";
case StructureType::ePhysicalDeviceAntiLagFeaturesAMD: return "PhysicalDeviceAntiLagFeaturesAMD";
case StructureType::eAntiLagDataAMD : return "AntiLagDataAMD";
case StructureType::eAntiLagPresentationInfoAMD : return "AntiLagPresentationInfoAMD";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX : return "PhysicalDeviceDenseGeometryFormatFeaturesAMDX";
case StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX: return "AccelerationStructureDenseGeometryFormatTrianglesDataAMDX";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case StructureType::eSurfaceCapabilitiesPresentId2KHR : return "SurfaceCapabilitiesPresentId2KHR";
case StructureType::ePresentId2KHR : return "PresentId2KHR";
case StructureType::ePhysicalDevicePresentId2FeaturesKHR : return "PhysicalDevicePresentId2FeaturesKHR";
@ -7779,10 +7787,13 @@ namespace VULKAN_HPP_NAMESPACE
case BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT : return "PushDescriptorsDescriptorBufferEXT";
case BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT : return "MicromapBuildInputReadOnlyEXT";
case BufferUsageFlagBits2::eMicromapStorageEXT : return "MicromapStorageEXT";
case BufferUsageFlagBits2::eDataGraphForeignDescriptorARM : return "DataGraphForeignDescriptorARM";
case BufferUsageFlagBits2::eTileMemoryQCOM : return "TileMemoryQCOM";
case BufferUsageFlagBits2::ePreprocessBufferEXT : return "PreprocessBufferEXT";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case BufferUsageFlagBits2::eCompressedDataDgf1AMDX: return "CompressedDataDgf1AMDX";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
case BufferUsageFlagBits2::eDataGraphForeignDescriptorARM: return "DataGraphForeignDescriptorARM";
case BufferUsageFlagBits2::eTileMemoryQCOM : return "TileMemoryQCOM";
case BufferUsageFlagBits2::ePreprocessBufferEXT : return "PreprocessBufferEXT";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -8785,7 +8796,10 @@ namespace VULKAN_HPP_NAMESPACE
case GeometryTypeKHR::eInstances : return "Instances";
case GeometryTypeKHR::eSpheresNV : return "SpheresNV";
case GeometryTypeKHR::eLinearSweptSpheresNV: return "LinearSweptSpheresNV";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
case GeometryTypeKHR::eDenseGeometryFormatTrianglesAMDX: return "DenseGeometryFormatTrianglesAMDX";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
default: return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -9886,6 +9900,19 @@ namespace VULKAN_HPP_NAMESPACE
}
}
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_AMDX_dense_geometry_format ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompressedTriangleFormatAMDX value )
{
switch ( value )
{
case CompressedTriangleFormatAMDX::eDgf1: return "Dgf1";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_shader_object ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCreateFlagBitsEXT value )

286
include/vulkan/vulkan_video.cppm
View file

@ -24,22 +24,102 @@ export namespace VULKAN_HPP_NAMESPACE
namespace VULKAN_HPP_VIDEO_NAMESPACE
{
//=================
//=== CONSTANTs ===
//=================
#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
//=== vulkan_video_codec_h264std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CpbCntListSize;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxChromaPlanes;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxNumListRef;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NoReferencePicture;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumElements;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumElements;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumLists;
#endif
#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
//=== vulkan_video_codec_h264std_decode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCountListSize;
#endif
#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
//=== vulkan_video_codec_h265std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetListSize;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileColsListSize;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileRowsListSize;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265CpbCntListSize;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxChromaPlanes;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDeltaPoc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDpbSize;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermPics;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermRefPicsSps;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxNumListRef;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxShortTermRefPicSets;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265NoReferencePicture;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteCompEntriesListSize;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteComponentsListSize;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumElements;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumElements;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumElements;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumElements;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SublayersListSize;
#endif
#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
//=== vulkan_video_codec_h265std_decode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265RefPicSetListSize;
#endif
#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
//=== vulkan_video_codec_vp9std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9LoopFilterAdjustments;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxRefFrames;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationPredProb;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationTreeProbs;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegments;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9NumRefFrames;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9RefsPerFrame;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9SegLvlMax;
#endif
#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
//=== vulkan_video_codec_av1std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1GlobalMotionParams;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1LoopFilterAdjustments;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxCdefFilterStrengths;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxLoopFilterStrengths;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCbPoints;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCrPoints;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPlanes;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosChroma;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosLuma;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumYPoints;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxSegments;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileCols;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileRows;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1NumRefFrames;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1PrimaryRefNone;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1RefsPerFrame;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SegLvlMax;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectIntegerMv;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectScreenContentTools;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SkipModeFrames;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1TotalRefsPerFrame;
#endif
//=============
//=== ENUMs ===
//=============
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount;
#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
//=== vulkan_video_codec_h264std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc;
@ -53,63 +133,74 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc;
#endif
#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
//=== vulkan_video_codec_h264std_decode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount;
#endif
#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
//=== vulkan_video_codec_h265std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType;
#endif
#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
//=== vulkan_video_codec_vp9std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Level;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ReferenceName;
#endif
#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
//=== vulkan_video_codec_av1std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode;
#endif
//===============
//=== STRUCTS ===
//===============
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags;
#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
//=== vulkan_video_codec_h264std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
//=== vulkan_video_codec_h264std_decode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ )
//=== vulkan_video_codec_h264std_encode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo;
@ -122,25 +213,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
//=== vulkan_video_codec_h265std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters;
@ -160,12 +236,88 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
//=== vulkan_video_codec_h265std_decode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ )
//=== vulkan_video_codec_h265std_encode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
//=== vulkan_video_codec_vp9std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ )
//=== vulkan_video_codec_vp9std_decode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
//=== vulkan_video_codec_av1std ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ )
//=== vulkan_video_codec_av1std_decode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags;
#endif
#if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ )
//=== vulkan_video_codec_av1std_encode ===
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo;
using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags;
#endif
} // namespace VULKAN_HPP_VIDEO_NAMESPACE
} // namespace VULKAN_HPP_NAMESPACE

90
include/vulkan/vulkan_video.hpp
View file

@ -63,6 +63,96 @@ namespace VULKAN_HPP_NAMESPACE
namespace VULKAN_HPP_VIDEO_NAMESPACE
{
//=================
//=== CONSTANTs ===
//=================
#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ )
//=== vulkan_video_codec_h264std ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264CpbCntListSize = 32;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264MaxChromaPlanes = 2;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264MaxNumListRef = 32;
VULKAN_HPP_CONSTEXPR_INLINE uint8_t H264NoReferencePicture = 0xFF;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList4X4NumElements = 16;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList4X4NumLists = 6;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList8X8NumElements = 64;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList8X8NumLists = 6;
#endif
#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ )
//=== vulkan_video_codec_h264std_decode ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t DecodeH264FieldOrderCountListSize = 2;
#endif
#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ )
//=== vulkan_video_codec_h265std ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetListSize = 6;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetTileColsListSize = 19;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetTileRowsListSize = 21;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265CpbCntListSize = 32;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxChromaPlanes = 2;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxDeltaPoc = 48;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxDpbSize = 16;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxLongTermPics = 16;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxLongTermRefPicsSps = 32;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxNumListRef = 15;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxShortTermRefPicSets = 64;
VULKAN_HPP_CONSTEXPR_INLINE uint8_t H265NoReferencePicture = 0xFF;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265PredictorPaletteComponentsListSize = 3;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265PredictorPaletteCompEntriesListSize = 128;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList16X16NumElements = 64;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList16X16NumLists = 6;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList32X32NumElements = 64;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList32X32NumLists = 2;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList4X4NumElements = 16;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList4X4NumLists = 6;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList8X8NumElements = 64;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList8X8NumLists = 6;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265SublayersListSize = 7;
#endif
#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ )
//=== vulkan_video_codec_h265std_decode ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t DecodeH265RefPicSetListSize = 8;
#endif
#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ )
//=== vulkan_video_codec_vp9std ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9LoopFilterAdjustments = 2;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxRefFrames = 4;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegmentationPredProb = 3;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegmentationTreeProbs = 7;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegments = 8;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9NumRefFrames = 8;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9RefsPerFrame = 3;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9SegLvlMax = 4;
#endif
#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ )
//=== vulkan_video_codec_av1std ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1GlobalMotionParams = 6;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1LoopFilterAdjustments = 2;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxCdefFilterStrengths = 8;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxLoopFilterStrengths = 4;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumCbPoints = 10;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumCrPoints = 10;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPlanes = 3;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPosChroma = 25;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPosLuma = 24;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumYPoints = 14;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxSegments = 8;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxTileCols = 64;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxTileRows = 64;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1NumRefFrames = 8;
VULKAN_HPP_CONSTEXPR_INLINE uint8_t Av1PrimaryRefNone = 7;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1RefsPerFrame = 7;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SegLvlMax = 8;
VULKAN_HPP_CONSTEXPR_INLINE uint8_t Av1SelectIntegerMv = 2;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SelectScreenContentTools = 2;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SkipModeFrames = 2;
VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1TotalRefsPerFrame = 8;
#endif
//=============
//=== ENUMs ===
//=============