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

Update for Vulkan-Docs 1.4.318

Browse source
This commit is contained in:
Jon Leech 2025-06-13 13:28:35 +01:00 • committed by Jon Leech
parent 1d6c53f654
commit b39ab380a4
20 changed files with 1676 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

42
include/vulkan/vulkan.cppm
View file

@ -975,6 +975,12 @@ using VULKAN_HPP_DEFAULT_DISPATCHER_TYPE;
//=== VK_KHR_maintenance9 ===
using VULKAN_HPP_NAMESPACE::DefaultVertexAttributeValueKHR;
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
using VULKAN_HPP_NAMESPACE::SurfaceCreateFlagBitsOHOS;
using VULKAN_HPP_NAMESPACE::SurfaceCreateFlagsOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
//=========================
//=== Index Type Traits ===
//=========================
@ -2771,6 +2777,12 @@ using VULKAN_HPP_DEFAULT_DISPATCHER_TYPE;
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2SpecVersion;
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
using VULKAN_HPP_NAMESPACE::OHOSSurfaceExtensionName;
using VULKAN_HPP_NAMESPACE::OHOSSurfaceSpecVersion;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividExtensionName;
using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividSpecVersion;
@ -2801,6 +2813,10 @@ using VULKAN_HPP_DEFAULT_DISPATCHER_TYPE;
using VULKAN_HPP_NAMESPACE::ARMFormatPackExtensionName;
using VULKAN_HPP_NAMESPACE::ARMFormatPackSpecVersion;
//=== VK_VALVE_fragment_density_map_layered ===
using VULKAN_HPP_NAMESPACE::VALVEFragmentDensityMapLayeredExtensionName;
using VULKAN_HPP_NAMESPACE::VALVEFragmentDensityMapLayeredSpecVersion;
//=== VK_KHR_robustness2 ===
using VULKAN_HPP_NAMESPACE::KHRRobustness2ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRRobustness2SpecVersion;
@ -4943,6 +4959,12 @@ using VULKAN_HPP_DEFAULT_DISPATCHER_TYPE;
using VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR;
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
using VULKAN_HPP_NAMESPACE::OHSurfaceCreateInfoOHOS;
using VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI;
using VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI;
@ -4972,6 +4994,11 @@ using VULKAN_HPP_DEFAULT_DISPATCHER_TYPE;
//=== VK_ARM_format_pack ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM;
//=== VK_VALVE_fragment_density_map_layered ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
using VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE;
//=== VK_KHR_robustness2 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT;
@ -7528,6 +7555,11 @@ export namespace std
template <> struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR>;
template <> struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>;
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
template <> struct hash<VULKAN_HPP_NAMESPACE::OHSurfaceCreateInfoOHOS>;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI>;
template <> struct hash<VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI>;
@ -7556,6 +7588,11 @@ export namespace std
//=== VK_ARM_format_pack ===
template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM>;
//=== VK_VALVE_fragment_density_map_layered ===
template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>;
template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE>;
template <> struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE>;
//=== VK_KHR_robustness2 ===
template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR>;
template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR>;
@ -8721,6 +8758,11 @@ export using ::PFN_vkDestroyIndirectExecutionSetEXT;
export using ::PFN_vkUpdateIndirectExecutionSetPipelineEXT;
export using ::PFN_vkUpdateIndirectExecutionSetShaderEXT;
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
export using ::PFN_vkCreateSurfaceOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
export using ::PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV;

4
include/vulkan/vulkan.h
View file

@ -96,4 +96,8 @@
#include "vulkan_beta.h"
#endif
#ifdef VK_USE_PLATFORM_OHOS
#include "vulkan_ohos.h"
#endif
#endif // VULKAN_H_

40
include/vulkan/vulkan.hpp
View file

@ -57,7 +57,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
#endif
static_assert( VK_HEADER_VERSION == 317, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 318, "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)
@ -5804,6 +5804,16 @@ VULKAN_HPP_INLINE void swap( UniqueHandle<Type, Dispatch> & lhs, UniqueHandle<Ty
return ::vkUpdateIndirectExecutionSetShaderEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites );
}
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
VkResult vkCreateSurfaceOHOS( VkInstance instance, const VkSurfaceCreateInfoOHOS * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCreateSurfaceOHOS( instance, pCreateInfo, pAllocator, pSurface );
}
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
@ -8542,6 +8552,12 @@ VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance9SpecVersion = VK_KHR_MAINTENANCE
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2ExtensionName = VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2SpecVersion = VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION;
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
VULKAN_HPP_CONSTEXPR_INLINE auto OHOSSurfaceExtensionName = VK_OHOS_SURFACE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto OHOSSurfaceSpecVersion = VK_OHOS_SURFACE_SPEC_VERSION;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividExtensionName = VK_HUAWEI_HDR_VIVID_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividSpecVersion = VK_HUAWEI_HDR_VIVID_SPEC_VERSION;
@ -8572,6 +8588,10 @@ VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessSpecVersion = VK_EX
VULKAN_HPP_CONSTEXPR_INLINE auto ARMFormatPackExtensionName = VK_ARM_FORMAT_PACK_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto ARMFormatPackSpecVersion = VK_ARM_FORMAT_PACK_SPEC_VERSION;
//=== VK_VALVE_fragment_density_map_layered ===
VULKAN_HPP_CONSTEXPR_INLINE auto VALVEFragmentDensityMapLayeredExtensionName = VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto VALVEFragmentDensityMapLayeredSpecVersion = VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION;
//=== VK_KHR_robustness2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2ExtensionName = VK_KHR_ROBUSTNESS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2SpecVersion = VK_KHR_ROBUSTNESS_2_SPEC_VERSION;
@ -10177,6 +10197,12 @@ namespace VULKAN_HPP_NAMESPACE
template <> struct StructExtends<PhysicalDeviceFormatPackFeaturesARM, PhysicalDeviceFeatures2>{ enum { value = true }; };
template <> struct StructExtends<PhysicalDeviceFormatPackFeaturesARM, DeviceCreateInfo>{ enum { value = true }; };
//=== VK_VALVE_fragment_density_map_layered ===
template <> struct StructExtends<PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, PhysicalDeviceFeatures2>{ enum { value = true }; };
template <> struct StructExtends<PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, DeviceCreateInfo>{ enum { value = true }; };
template <> struct StructExtends<PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE, PhysicalDeviceProperties2>{ enum { value = true }; };
template <> struct StructExtends<PipelineFragmentDensityMapLayeredCreateInfoVALVE, GraphicsPipelineCreateInfo>{ enum { value = true }; };
//=== VK_KHR_robustness2 ===
template <> struct StructExtends<PhysicalDeviceRobustness2FeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
template <> struct StructExtends<PhysicalDeviceRobustness2FeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
@ -11547,6 +11573,13 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0;
PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0;
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS = 0;
#else
PFN_dummy vkCreateSurfaceOHOS_placeholder = 0;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0;
@ -12858,6 +12891,11 @@ namespace VULKAN_HPP_NAMESPACE
vkUpdateIndirectExecutionSetPipelineEXT = PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetPipelineEXT" ) );
vkUpdateIndirectExecutionSetShaderEXT = PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetShaderEXT" ) );
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
vkCreateSurfaceOHOS = PFN_vkCreateSurfaceOHOS( vkGetInstanceProcAddr( instance, "vkCreateSurfaceOHOS" ) );
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) );

43
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 317
#define VK_HEADER_VERSION 318
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1277,6 +1277,7 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586001,
VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586002,
VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586003,
VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS = 1000587000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI = 1000590000,
VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI = 1000590001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV = 1000593000,
@ -1289,6 +1290,9 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM = 1000609000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE = 1000611000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE = 1000611001,
VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE = 1000611002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001,
#ifdef VK_ENABLE_BETA_EXTENSIONS
@ -3075,6 +3079,7 @@ typedef VkFlags VkFramebufferCreateFlags;
typedef enum VkRenderPassCreateFlagBits {
VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002,
VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000004,
VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkRenderPassCreateFlagBits;
typedef VkFlags VkRenderPassCreateFlags;
@ -7048,6 +7053,7 @@ typedef enum VkRenderingFlagBits {
VK_RENDERING_RESUMING_BIT = 0x00000004,
VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008,
VK_RENDERING_CONTENTS_INLINE_BIT_KHR = 0x00000010,
VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000020,
VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT,
VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT,
VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT,
@ -8009,6 +8015,7 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BI
static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM = 0x2000000000ULL;
static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL;
static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL;
static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x10000000000ULL;
typedef VkFlags64 VkBufferUsageFlags2;
@ -12381,10 +12388,8 @@ typedef enum VkComponentTypeKHR {
VK_COMPONENT_TYPE_BFLOAT16_KHR = 1000141000,
VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000,
VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001,
VK_COMPONENT_TYPE_FLOAT_E4M3_NV = 1000491002,
VK_COMPONENT_TYPE_FLOAT_E5M2_NV = 1000491003,
VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000567000,
VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000567001,
VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000491002,
VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000491003,
VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR,
VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR,
VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR,
@ -12396,6 +12401,8 @@ typedef enum VkComponentTypeKHR {
VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR,
VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR,
VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR,
VK_COMPONENT_TYPE_FLOAT_E4M3_NV = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT,
VK_COMPONENT_TYPE_FLOAT_E5M2_NV = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT,
VK_COMPONENT_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
} VkComponentTypeKHR;
@ -20023,7 +20030,7 @@ typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM {
typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM {
VkStructureType sType;
const void* pNext;
void* pNext;
size_t tensorCaptureReplayDescriptorDataSize;
size_t tensorViewCaptureReplayDescriptorDataSize;
size_t tensorDescriptorSize;
@ -22087,6 +22094,30 @@ typedef struct VkPhysicalDeviceFormatPackFeaturesARM {
// VK_VALVE_fragment_density_map_layered is a preprocessor guard. Do not pass it to API calls.
#define VK_VALVE_fragment_density_map_layered 1
#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION 1
#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME "VK_VALVE_fragment_density_map_layered"
typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE {
VkStructureType sType;
void* pNext;
VkBool32 fragmentDensityMapLayered;
} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE {
VkStructureType sType;
void* pNext;
uint32_t maxFragmentDensityMapLayers;
} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE {
VkStructureType sType;
const void* pNext;
uint32_t maxFragmentDensityMapLayers;
} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE;
// VK_NV_present_metering is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_present_metering 1
#define VK_NV_PRESENT_METERING_SPEC_VERSION 1

52
include/vulkan/vulkan_enums.hpp
View file

@ -11,6 +11,8 @@
// include-what-you-use: make sure, vulkan.hpp is used by code-completers
// IWYU pragma: private; include "vulkan.hpp"
#include <type_traits> // for std::underlying_type
namespace VULKAN_HPP_NAMESPACE
{
template <typename FlagBitsType>
@ -1633,6 +1635,9 @@ namespace VULKAN_HPP_NAMESPACE
eVideoDecodeH264InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR,
eVideoDecodeH265InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR,
eVideoDecodeAv1InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR,
#if defined( VK_USE_PLATFORM_OHOS )
eOhSurfaceCreateInfoOHOS = VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS,
#endif /*VK_USE_PLATFORM_OHOS*/
ePhysicalDeviceHdrVividFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI,
eHdrVividDynamicMetadataHUAWEI = VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI,
ePhysicalDeviceCooperativeMatrix2FeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV,
@ -1648,6 +1653,9 @@ namespace VULKAN_HPP_NAMESPACE
ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT,
ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT,
ePhysicalDeviceFormatPackFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM,
ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE,
ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE,
ePipelineFragmentDensityMapLayeredCreateInfoVALVE = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE,
ePhysicalDeviceRobustness2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR,
ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
ePhysicalDeviceRobustness2PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR,
@ -4196,7 +4204,8 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper class for enum VkRenderPassCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateFlagBits.html
enum class RenderPassCreateFlagBits : VkRenderPassCreateFlags{
eTransformQCOM = VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM
eTransformQCOM = VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM,
ePerLayerFragmentDensityVALVE = VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE
};
@ -4210,7 +4219,8 @@ namespace VULKAN_HPP_NAMESPACE
using WrappedType = VkRenderPassCreateFlagBits;
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR RenderPassCreateFlags allFlags =
RenderPassCreateFlagBits::eTransformQCOM;
RenderPassCreateFlagBits::eTransformQCOM
| RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE;
};
// wrapper class for enum VkSubpassDescriptionFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionFlagBits.html
@ -5370,7 +5380,8 @@ namespace VULKAN_HPP_NAMESPACE
eResuming = VK_RENDERING_RESUMING_BIT,
eEnableLegacyDitheringEXT = VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT,
eContentsInlineKHR = VK_RENDERING_CONTENTS_INLINE_BIT_KHR,
eContentsInlineEXT = VK_RENDERING_CONTENTS_INLINE_BIT_EXT
eContentsInlineEXT = VK_RENDERING_CONTENTS_INLINE_BIT_EXT,
ePerLayerFragmentDensityVALVE = VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE
};
using RenderingFlagBitsKHR = RenderingFlagBits;
@ -5390,7 +5401,8 @@ namespace VULKAN_HPP_NAMESPACE
| RenderingFlagBits::eSuspending
| RenderingFlagBits::eResuming
| RenderingFlagBits::eEnableLegacyDitheringEXT
| RenderingFlagBits::eContentsInlineKHR;
| RenderingFlagBits::eContentsInlineKHR
| RenderingFlagBits::ePerLayerFragmentDensityVALVE;
};
// wrapper class for enum VkFormatFeatureFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlagBits2.html
@ -5608,7 +5620,8 @@ namespace VULKAN_HPP_NAMESPACE
eDescriptorBufferEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT,
eDisallowOpacityMicromapARM = VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM,
eCaptureDataKHR = VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR,
eIndirectBindableEXT = VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT
eIndirectBindableEXT = VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT,
ePerLayerFragmentDensityVALVE = VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE
};
using PipelineCreateFlagBits2KHR = PipelineCreateFlagBits2;
@ -5662,7 +5675,8 @@ namespace VULKAN_HPP_NAMESPACE
| PipelineCreateFlagBits2::eDescriptorBufferEXT
| PipelineCreateFlagBits2::eDisallowOpacityMicromapARM
| PipelineCreateFlagBits2::eCaptureDataKHR
| PipelineCreateFlagBits2::eIndirectBindableEXT;
| PipelineCreateFlagBits2::eIndirectBindableEXT
| PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE;
};
// wrapper class for enum VkBufferUsageFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlagBits2.html
@ -9162,10 +9176,10 @@ namespace VULKAN_HPP_NAMESPACE
eBfloat16 = VK_COMPONENT_TYPE_BFLOAT16_KHR,
eSint8PackedNV = VK_COMPONENT_TYPE_SINT8_PACKED_NV,
eUint8PackedNV = VK_COMPONENT_TYPE_UINT8_PACKED_NV,
eFloatE4M3NV = VK_COMPONENT_TYPE_FLOAT_E4M3_NV,
eFloatE5M2NV = VK_COMPONENT_TYPE_FLOAT_E5M2_NV,
eFloat8E4M3EXT = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT,
eFloat8E5M2EXT = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT
eFloatE4M3 = VK_COMPONENT_TYPE_FLOAT_E4M3_NV,
eFloat8E5M2EXT = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT,
eFloatE5M2 = VK_COMPONENT_TYPE_FLOAT_E5M2_NV
};
using ComponentTypeNV = ComponentTypeKHR;
@ -9763,6 +9777,26 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
enum class SurfaceCreateFlagBitsOHOS : VkSurfaceCreateFlagsOHOS{};
// wrapper using for bitmask VkSurfaceCreateFlagsOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCreateFlagsOHOS.html
using SurfaceCreateFlagsOHOS = Flags<SurfaceCreateFlagBitsOHOS>;
template <> struct FlagTraits<SurfaceCreateFlagBitsOHOS>
{
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true;
static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceCreateFlagsOHOS allFlags = {};
};
#endif /*VK_USE_PLATFORM_OHOS*/
//===========================================================

18
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -486,6 +486,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_depth_clamp_zero_one",
"VK_EXT_vertex_attribute_robustness",
"VK_ARM_format_pack",
"VK_VALVE_fragment_density_map_layered",
"VK_KHR_robustness2",
#if defined( VK_ENABLE_BETA_EXTENSIONS )
"VK_NV_present_metering",
@ -565,7 +566,11 @@ namespace VULKAN_HPP_NAMESPACE
"VK_GOOGLE_surfaceless_query",
"VK_LUNARG_direct_driver_loading",
"VK_EXT_layer_settings",
"VK_NV_display_stereo" };
"VK_NV_display_stereo",
#if defined( VK_USE_PLATFORM_OHOS )
"VK_OHOS_surface"
#endif /*VK_USE_PLATFORM_OHOS*/
};
return instanceExtensions;
}
@ -937,6 +942,9 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_EXT_depth_clamp_control", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { { } } } } },
{ "VK_KHR_maintenance9", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { { } } } } },
{ "VK_KHR_video_maintenance2", { { "VK_VERSION_1_0", { { "VK_KHR_video_queue", } } } } },
#if defined( VK_USE_PLATFORM_OHOS )
{ "VK_OHOS_surface", { { "VK_VERSION_1_0", { { "VK_KHR_surface", } } } } },
#endif /*VK_USE_PLATFORM_OHOS*/
{ "VK_HUAWEI_hdr_vivid", { { "VK_VERSION_1_0", { { "VK_EXT_hdr_metadata", "VK_KHR_get_physical_device_properties2", "VK_KHR_swapchain", } } }, { "VK_VERSION_1_1", { { "VK_EXT_hdr_metadata", "VK_KHR_swapchain", } } } } },
{ "VK_NV_cooperative_matrix2", { { "VK_VERSION_1_0", { { "VK_KHR_cooperative_matrix", } } } } },
{ "VK_ARM_pipeline_opacity_micromap", { { "VK_VERSION_1_0", { { "VK_EXT_opacity_micromap", } } } } },
@ -945,6 +953,7 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_METAL_EXT*/
{ "VK_KHR_depth_clamp_zero_one", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { { } } } } },
{ "VK_EXT_vertex_attribute_robustness", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { { } } } } },
{ "VK_VALVE_fragment_density_map_layered", { { "VK_VERSION_1_0", { { "VK_EXT_fragment_density_map", "VK_KHR_maintenance5", } } }, { "VK_VERSION_1_4", { { "VK_EXT_fragment_density_map", } } } } },
{ "VK_KHR_robustness2", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { { } } } } },
{ "VK_EXT_fragment_density_map_offset", { { "VK_VERSION_1_0", { { "VK_EXT_fragment_density_map", "VK_KHR_create_renderpass2", "VK_KHR_dynamic_rendering", "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { { "VK_EXT_fragment_density_map", "VK_KHR_create_renderpass2", "VK_KHR_dynamic_rendering", } } }, { "VK_VERSION_1_2", { { "VK_EXT_fragment_density_map", "VK_KHR_dynamic_rendering", } } }, { "VK_VERSION_1_3", { { "VK_EXT_fragment_density_map", } } } } },
{ "VK_EXT_zero_initialize_device_memory", { { "VK_VERSION_1_0", { { "VK_KHR_get_physical_device_properties2", } } }, { "VK_VERSION_1_1", { { } } } } } };
@ -1695,6 +1704,7 @@ false;
|| ( extension == "VK_KHR_depth_clamp_zero_one" )
|| ( extension == "VK_EXT_vertex_attribute_robustness" )
|| ( extension == "VK_ARM_format_pack" )
|| ( extension == "VK_VALVE_fragment_density_map_layered" )
|| ( extension == "VK_KHR_robustness2" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_present_metering" )
@ -1773,7 +1783,11 @@ false;
|| ( extension == "VK_GOOGLE_surfaceless_query" )
|| ( extension == "VK_LUNARG_direct_driver_loading" )
|| ( extension == "VK_EXT_layer_settings" )
|| ( extension == "VK_NV_display_stereo" );
|| ( extension == "VK_NV_display_stereo" )
#if defined( VK_USE_PLATFORM_OHOS )
|| ( extension == "VK_OHOS_surface" )
#endif /*VK_USE_PLATFORM_OHOS*/
;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension )

51
include/vulkan/vulkan_funcs.hpp
View file

@ -26079,6 +26079,57 @@ VULKAN_HPP_ASSERT( d.vkUpdateIndirectExecutionSetShaderEXT && "Function <vkUpdat
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
// wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createSurfaceOHOS( const VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkCreateSurfaceOHOS( static_cast<VkInstance>( m_instance ), reinterpret_cast<const VkSurfaceCreateInfoOHOS *>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ), reinterpret_cast<VkSurfaceKHR *>( pSurface ) ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type Instance::createSurfaceOHOS( const VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
#if (VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCreateSurfaceOHOS && "Function <vkCreateSurfaceOHOS> requires <VK_OHOS_surface>" );
#endif
VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSurfaceOHOS( m_instance, reinterpret_cast<const VkSurfaceCreateInfoOHOS *>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createSurfaceOHOS" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surface ) );
}
# ifndef VULKAN_HPP_NO_SMART_HANDLE
// wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type Instance::createSurfaceOHOSUnique( const VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator, Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
#if (VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCreateSurfaceOHOS && "Function <vkCreateSurfaceOHOS> requires <VK_OHOS_surface>" );
#endif
VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateSurfaceOHOS( m_instance, reinterpret_cast<const VkSurfaceCreateInfoOHOS *>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createSurfaceOHOSUnique" );
return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>( surface, detail::ObjectDestroy<Instance, Dispatch>( *this, allocator, d ) ) );
}
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===

30
include/vulkan/vulkan_handles.hpp
View file

@ -2084,6 +2084,12 @@ namespace VULKAN_HPP_NAMESPACE
struct VideoDecodeH265InlineSessionParametersInfoKHR;
struct VideoDecodeAV1InlineSessionParametersInfoKHR;
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
struct OHSurfaceCreateInfoOHOS;
using SurfaceCreateInfoOHOS = OHSurfaceCreateInfoOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
struct PhysicalDeviceHdrVividFeaturesHUAWEI;
struct HdrVividDynamicMetadataHUAWEI;
@ -2113,6 +2119,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_ARM_format_pack ===
struct PhysicalDeviceFormatPackFeaturesARM;
//=== VK_VALVE_fragment_density_map_layered ===
struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
struct PipelineFragmentDensityMapLayeredCreateInfoVALVE;
//=== VK_KHR_robustness2 ===
struct PhysicalDeviceRobustness2FeaturesKHR;
using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR;
@ -16616,6 +16627,25 @@ class IndirectExecutionSetEXT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
// wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result createSurfaceOHOS( const VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS * pCreateInfo, const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, VULKAN_HPP_NAMESPACE::SurfaceKHR * pSurface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type createSurfaceOHOS( const VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# ifndef VULKAN_HPP_NO_SMART_HANDLE
// wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type createSurfaceOHOSUnique( const VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS & createInfo, Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
# endif /* VULKAN_HPP_NO_SMART_HANDLE */
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#endif /*VK_USE_PLATFORM_OHOS*/
operator VkInstance() const VULKAN_HPP_NOEXCEPT
{
return m_instance;

51
include/vulkan/vulkan_hash.hpp
View file

@ -7504,6 +7504,21 @@ template <> struct hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT>
}
};
#if defined( VK_USE_PLATFORM_OHOS )
template <> struct hash<VULKAN_HPP_NAMESPACE::OHSurfaceCreateInfoOHOS>
{
std::size_t operator()(VULKAN_HPP_NAMESPACE::OHSurfaceCreateInfoOHOS const & oHSurfaceCreateInfoOHOS) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, oHSurfaceCreateInfoOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, oHSurfaceCreateInfoOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, oHSurfaceCreateInfoOHOS.flags );
VULKAN_HPP_HASH_COMBINE( seed, oHSurfaceCreateInfoOHOS.window );
return seed;
}
};
#endif /*VK_USE_PLATFORM_OHOS*/
template <> struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT>
{
std::size_t operator()(VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
@ -9290,6 +9305,30 @@ template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreen
}
};
template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>
{
std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & physicalDeviceFragmentDensityMapLayeredFeaturesVALVE) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.fragmentDensityMapLayered );
return seed;
}
};
template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE>
{
std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & physicalDeviceFragmentDensityMapLayeredPropertiesVALVE) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.maxFragmentDensityMapLayers );
return seed;
}
};
template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>
{
std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & physicalDeviceFragmentDensityMapOffsetFeaturesEXT) const VULKAN_HPP_NOEXCEPT
@ -13534,6 +13573,18 @@ template <> struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropert
}
};
template <> struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE>
{
std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE const & pipelineFragmentDensityMapLayeredCreateInfoVALVE) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.sType );
VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.pNext );
VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.maxFragmentDensityMapLayers );
return seed;
}
};
template <> struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV>
{
std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV) const VULKAN_HPP_NOEXCEPT

51
include/vulkan/vulkan_ohos.h Normal file
View file

@ -0,0 +1,51 @@
#ifndef VULKAN_OHOS_H_
#define VULKAN_OHOS_H_ 1
/*
** Copyright 2015-2025 The Khronos Group Inc.
**
** SPDX-License-Identifier: Apache-2.0
*/
/*
** This header is generated from the Khronos Vulkan XML API Registry.
**
*/
#ifdef __cplusplus
extern "C" {
#endif
// VK_OHOS_surface is a preprocessor guard. Do not pass it to API calls.
#define VK_OHOS_surface 1
typedef struct NativeWindow OHNativeWindow;
#define VK_OHOS_SURFACE_SPEC_VERSION 1
#define VK_OHOS_SURFACE_EXTENSION_NAME "VK_OHOS_surface"
typedef VkFlags VkSurfaceCreateFlagsOHOS;
typedef struct VkOHSurfaceCreateInfoOHOS {
VkStructureType sType;
const void* pNext;
VkSurfaceCreateFlagsOHOS flags;
OHNativeWindow* window;
} VkOHSurfaceCreateInfoOHOS;
typedef VkOHSurfaceCreateInfoOHOS VkSurfaceCreateInfoOHOS;
typedef VkResult (VKAPI_PTR *PFN_vkCreateSurfaceOHOS)(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS(
VkInstance instance,
const VkSurfaceCreateInfoOHOS* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface);
#endif
#ifdef __cplusplus
}
#endif
#endif

49
include/vulkan/vulkan_raii.hpp
View file

@ -317,6 +317,11 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_calibrated_timestamps ===
vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) );
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
vkCreateSurfaceOHOS = PFN_vkCreateSurfaceOHOS( vkGetInstanceProcAddr( instance, "vkCreateSurfaceOHOS" ) );
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) );
@ -605,6 +610,13 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_calibrated_timestamps ===
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0;
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS = 0;
#else
PFN_dummy vkCreateSurfaceOHOS_placeholder = 0;
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0;
@ -3059,6 +3071,13 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createScreenSurfaceQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo, VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
// wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type createSurfaceOHOS( VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS const & createInfo, VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
#endif /*VK_USE_PLATFORM_OHOS*/
private:
@ -11742,6 +11761,15 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_GGP*/
#endif
#if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
#if defined( VK_USE_PLATFORM_OHOS )
SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS const & createInfo, VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
{
*this = instance.createSurfaceOHOS( createInfo, allocator );
}
#endif /*VK_USE_PLATFORM_OHOS*/
#endif
#if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
#if defined( VK_USE_PLATFORM_VI_NN )
SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo, VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
@ -24348,6 +24376,27 @@ VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateIndirectExecutionSetShaderEXT && "Fu
}
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
// wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type Instance::createSurfaceOHOS( VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS const & createInfo, VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
{
VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSurfaceOHOS( static_cast<VkInstance>( m_instance ), reinterpret_cast<const VkSurfaceCreateInfoOHOS *>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ), reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
#if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
return VULKAN_HPP_UNEXPECTED( result );
#else
VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createSurfaceOHOS" );
#endif
}
return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
}
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_NV_cooperative_matrix2 ===
// wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html

22
include/vulkan/vulkan_static_assertions.hpp
View file

@ -5701,6 +5701,14 @@ VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSess
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR>::value, "VideoDecodeAV1InlineSessionParametersInfoKHR is not nothrow_move_constructible!" );
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OHSurfaceCreateInfoOHOS ) == sizeof( VkOHSurfaceCreateInfoOHOS ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::OHSurfaceCreateInfoOHOS>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::OHSurfaceCreateInfoOHOS>::value, "OHSurfaceCreateInfoOHOS is not nothrow_move_constructible!" );
#endif /*VK_USE_PLATFORM_OHOS*/
//=== VK_HUAWEI_hdr_vivid ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceHdrVividFeaturesHUAWEI ), "struct and wrapper have different size!" );
@ -5765,6 +5773,20 @@ VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPack
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM>::value, "PhysicalDeviceFormatPackFeaturesARM is not nothrow_move_constructible!" );
//=== VK_VALVE_fragment_density_map_layered ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE ) == sizeof( VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>::value, "PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE ) == sizeof( VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE>::value, "PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE ) == sizeof( VkPipelineFragmentDensityMapLayeredCreateInfoVALVE ), "struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE>::value, "PipelineFragmentDensityMapLayeredCreateInfoVALVE is not nothrow_move_constructible!" );
//=== VK_KHR_robustness2 ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR ) == sizeof( VkPhysicalDeviceRobustness2FeaturesKHR ), "struct and wrapper have different size!" );

439
include/vulkan/vulkan_structs.hpp
View file

@ -66020,6 +66020,129 @@ auto operator<=>( MutableDescriptorTypeCreateInfoEXT const & ) const = default;
};
using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
#if defined( VK_USE_PLATFORM_OHOS )
// wrapper struct for struct VkOHSurfaceCreateInfoOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOHSurfaceCreateInfoOHOS.html
struct OHSurfaceCreateInfoOHOS
{
using NativeType = VkOHSurfaceCreateInfoOHOS;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOhSurfaceCreateInfoOHOS;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR OHSurfaceCreateInfoOHOS(VULKAN_HPP_NAMESPACE::SurfaceCreateFlagsOHOS flags_ = {}, OHNativeWindow * window_ = {}, const void * pNext_ = nullptr) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }, flags{ flags_ }, window{ window_ }
{}
VULKAN_HPP_CONSTEXPR OHSurfaceCreateInfoOHOS( OHSurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default;
OHSurfaceCreateInfoOHOS( VkOHSurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT
: OHSurfaceCreateInfoOHOS( *reinterpret_cast<OHSurfaceCreateInfoOHOS const *>( &rhs ) )
{}
OHSurfaceCreateInfoOHOS & operator=( OHSurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
OHSurfaceCreateInfoOHOS & operator=( VkOHSurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::OHSurfaceCreateInfoOHOS const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 OHSurfaceCreateInfoOHOS & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 OHSurfaceCreateInfoOHOS & setFlags( VULKAN_HPP_NAMESPACE::SurfaceCreateFlagsOHOS flags_ ) VULKAN_HPP_NOEXCEPT
{
flags = flags_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 OHSurfaceCreateInfoOHOS & setWindow( OHNativeWindow * window_ ) VULKAN_HPP_NOEXCEPT
{
window = window_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkOHSurfaceCreateInfoOHOS const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkOHSurfaceCreateInfoOHOS*>( this );
}
operator VkOHSurfaceCreateInfoOHOS &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkOHSurfaceCreateInfoOHOS*>( this );
}
operator VkOHSurfaceCreateInfoOHOS const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkOHSurfaceCreateInfoOHOS*>( this );
}
operator VkOHSurfaceCreateInfoOHOS *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkOHSurfaceCreateInfoOHOS*>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
#if 14 <= VULKAN_HPP_CPP_VERSION
auto
#else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::SurfaceCreateFlagsOHOS const &, OHNativeWindow * const &>
#endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, flags, window );
}
#endif
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
auto operator<=>( OHSurfaceCreateInfoOHOS const & ) const = default;
#else
bool operator==( OHSurfaceCreateInfoOHOS 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 )
&& ( flags == rhs.flags )
&& ( window == rhs.window );
#endif
}
bool operator!=( OHSurfaceCreateInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eOhSurfaceCreateInfoOHOS;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::SurfaceCreateFlagsOHOS flags = {};
OHNativeWindow * window = {};
};
template <>
struct CppType<StructureType, StructureType::eOhSurfaceCreateInfoOHOS>
{
using Type = OHSurfaceCreateInfoOHOS;
};
using SurfaceCreateInfoOHOS = OHSurfaceCreateInfoOHOS;
#endif /*VK_USE_PLATFORM_OHOS*/
// wrapper struct for struct VkOpaqueCaptureDescriptorDataCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpaqueCaptureDescriptorDataCreateInfoEXT.html
struct OpaqueCaptureDescriptorDataCreateInfoEXT
{
@ -75314,7 +75437,7 @@ auto operator<=>( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & ) cons
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferTensorPropertiesARM(size_t tensorCaptureReplayDescriptorDataSize_ = {}, size_t tensorViewCaptureReplayDescriptorDataSize_ = {}, size_t tensorDescriptorSize_ = {}, const void * pNext_ = nullptr) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferTensorPropertiesARM(size_t tensorCaptureReplayDescriptorDataSize_ = {}, size_t tensorViewCaptureReplayDescriptorDataSize_ = {}, size_t tensorDescriptorSize_ = {}, void * pNext_ = nullptr) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }, tensorCaptureReplayDescriptorDataSize{ tensorCaptureReplayDescriptorDataSize_ }, tensorViewCaptureReplayDescriptorDataSize{ tensorViewCaptureReplayDescriptorDataSize_ }, tensorDescriptorSize{ tensorDescriptorSize_ }
{}
@ -75336,7 +75459,7 @@ VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferTensorPropertiesARM(size_t te
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
@ -75386,7 +75509,7 @@ VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferTensorPropertiesARM(size_t te
#if 14 <= VULKAN_HPP_CPP_VERSION
auto
#else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, size_t const &, size_t const &, size_t const &>
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, size_t const &, size_t const &, size_t const &>
#endif
reflect() const VULKAN_HPP_NOEXCEPT
{
@ -75419,7 +75542,7 @@ auto operator<=>( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & ) co
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferTensorPropertiesARM;
const void * pNext = {};
void * pNext = {};
size_t tensorCaptureReplayDescriptorDataSize = {};
size_t tensorViewCaptureReplayDescriptorDataSize = {};
size_t tensorDescriptorSize = {};
@ -80827,6 +80950,202 @@ auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const & ) const =
using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT;
};
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE.html
struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE
{
using NativeType = VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE(VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapLayered_ = {}, void * pNext_ = nullptr) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }, fragmentDensityMapLayered{ fragmentDensityMapLayered_ }
{}
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( *reinterpret_cast<PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const *>( &rhs ) )
{}
PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & operator=( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & operator=( VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const *>( &rhs );
return *this;
}
operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>( this );
}
operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>( this );
}
operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>( this );
}
operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE*>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
#if 14 <= VULKAN_HPP_CPP_VERSION
auto
#else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
#endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, fragmentDensityMapLayered );
}
#endif
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
auto operator<=>( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE 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 )
&& ( fragmentDensityMapLayered == rhs.fragmentDensityMapLayered );
#endif
}
bool operator!=( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 fragmentDensityMapLayered = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>
{
using Type = PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
};
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE.html
struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE
{
using NativeType = VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE(uint32_t maxFragmentDensityMapLayers_ = {}, void * pNext_ = nullptr) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }, maxFragmentDensityMapLayers{ maxFragmentDensityMapLayers_ }
{}
VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( *reinterpret_cast<PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const *>( &rhs ) )
{}
PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE & operator=( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE & operator=( VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const *>( &rhs );
return *this;
}
operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*>( this );
}
operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*>( this );
}
operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*>( this );
}
operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE*>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
#if 14 <= VULKAN_HPP_CPP_VERSION
auto
#else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
#endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, maxFragmentDensityMapLayers );
}
#endif
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
auto operator<=>( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & ) const = default;
#else
bool operator==( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE 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 )
&& ( maxFragmentDensityMapLayers == rhs.maxFragmentDensityMapLayers );
#endif
}
bool operator!=( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
void * pNext = {};
uint32_t maxFragmentDensityMapLayers = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE>
{
using Type = PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
};
// wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.html
struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT
{
@ -114509,6 +114828,118 @@ VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticKHR(std::array<char,VK_MAX_DE
using Type = PipelineExecutableStatisticKHR;
};
// wrapper struct for struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineFragmentDensityMapLayeredCreateInfoVALVE.html
struct PipelineFragmentDensityMapLayeredCreateInfoVALVE
{
using NativeType = VkPipelineFragmentDensityMapLayeredCreateInfoVALVE;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PipelineFragmentDensityMapLayeredCreateInfoVALVE(uint32_t maxFragmentDensityMapLayers_ = {}, const void * pNext_ = nullptr) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }, maxFragmentDensityMapLayers{ maxFragmentDensityMapLayers_ }
{}
VULKAN_HPP_CONSTEXPR PipelineFragmentDensityMapLayeredCreateInfoVALVE( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PipelineFragmentDensityMapLayeredCreateInfoVALVE( VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
: PipelineFragmentDensityMapLayeredCreateInfoVALVE( *reinterpret_cast<PipelineFragmentDensityMapLayeredCreateInfoVALVE const *>( &rhs ) )
{}
PipelineFragmentDensityMapLayeredCreateInfoVALVE & operator=( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PipelineFragmentDensityMapLayeredCreateInfoVALVE & operator=( VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE & setMaxFragmentDensityMapLayers( uint32_t maxFragmentDensityMapLayers_ ) VULKAN_HPP_NOEXCEPT
{
maxFragmentDensityMapLayers = maxFragmentDensityMapLayers_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*>( this );
}
operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*>( this );
}
operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*>( this );
}
operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPipelineFragmentDensityMapLayeredCreateInfoVALVE*>( this );
}
#if defined( VULKAN_HPP_USE_REFLECT )
#if 14 <= VULKAN_HPP_CPP_VERSION
auto
#else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
#endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, maxFragmentDensityMapLayers );
}
#endif
#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
auto operator<=>( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & ) const = default;
#else
bool operator==( PipelineFragmentDensityMapLayeredCreateInfoVALVE 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 )
&& ( maxFragmentDensityMapLayers == rhs.maxFragmentDensityMapLayers );
#endif
}
bool operator!=( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE;
const void * pNext = {};
uint32_t maxFragmentDensityMapLayers = {};
};
template <>
struct CppType<StructureType, StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE>
{
using Type = PipelineFragmentDensityMapLayeredCreateInfoVALVE;
};
// wrapper struct for struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html
struct PipelineFragmentShadingRateEnumStateCreateInfoNV
{

33
include/vulkan/vulkan_to_string.hpp
View file

@ -845,6 +845,7 @@ namespace VULKAN_HPP_NAMESPACE
{
std::string result = "{";
if ( value & RenderPassCreateFlagBits::eTransformQCOM ) result += " TransformQCOM |";
if ( value & RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE ) result += " PerLayerFragmentDensityVALVE |";
if ( result.size() > 1 )
result.back() = '}';
@ -1362,6 +1363,7 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & RenderingFlagBits::eResuming ) result += " Resuming |";
if ( value & RenderingFlagBits::eEnableLegacyDitheringEXT ) result += " EnableLegacyDitheringEXT |";
if ( value & RenderingFlagBits::eContentsInlineKHR ) result += " ContentsInlineKHR |";
if ( value & RenderingFlagBits::ePerLayerFragmentDensityVALVE ) result += " PerLayerFragmentDensityVALVE |";
if ( result.size() > 1 )
result.back() = '}';
@ -1485,6 +1487,7 @@ namespace VULKAN_HPP_NAMESPACE
if ( value & PipelineCreateFlagBits2::eDisallowOpacityMicromapARM ) result += " DisallowOpacityMicromapARM |";
if ( value & PipelineCreateFlagBits2::eCaptureDataKHR ) result += " CaptureDataKHR |";
if ( value & PipelineCreateFlagBits2::eIndirectBindableEXT ) result += " IndirectBindableEXT |";
if ( value & PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE ) result += " PerLayerFragmentDensityVALVE |";
if ( result.size() > 1 )
result.back() = '}';
@ -3093,6 +3096,15 @@ namespace VULKAN_HPP_NAMESPACE
return "None";
}
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCreateFlagsOHOS )
{
return "{}";
}
#endif /*VK_USE_PLATFORM_OHOS*/
//=======================
@ -4276,6 +4288,9 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR : return "VideoDecodeH264InlineSessionParametersInfoKHR";
case StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR : return "VideoDecodeH265InlineSessionParametersInfoKHR";
case StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR : return "VideoDecodeAv1InlineSessionParametersInfoKHR";
#if defined( VK_USE_PLATFORM_OHOS )
case StructureType::eOhSurfaceCreateInfoOHOS : return "OhSurfaceCreateInfoOHOS";
#endif /*VK_USE_PLATFORM_OHOS*/
case StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI : return "PhysicalDeviceHdrVividFeaturesHUAWEI";
case StructureType::eHdrVividDynamicMetadataHUAWEI : return "HdrVividDynamicMetadataHUAWEI";
case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV : return "PhysicalDeviceCooperativeMatrix2FeaturesNV";
@ -4290,6 +4305,9 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR : return "PhysicalDeviceDepthClampZeroOneFeaturesKHR";
case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT : return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
case StructureType::ePhysicalDeviceFormatPackFeaturesARM : return "PhysicalDeviceFormatPackFeaturesARM";
case StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE : return "PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE";
case StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE : return "PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE";
case StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE : return "PipelineFragmentDensityMapLayeredCreateInfoVALVE";
case StructureType::ePhysicalDeviceRobustness2FeaturesKHR : return "PhysicalDeviceRobustness2FeaturesKHR";
case StructureType::ePhysicalDeviceRobustness2PropertiesKHR : return "PhysicalDeviceRobustness2PropertiesKHR";
#if defined( VK_ENABLE_BETA_EXTENSIONS )
@ -6077,6 +6095,7 @@ namespace VULKAN_HPP_NAMESPACE
switch ( value )
{
case RenderPassCreateFlagBits::eTransformQCOM : return "TransformQCOM";
case RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
@ -6764,6 +6783,7 @@ namespace VULKAN_HPP_NAMESPACE
case RenderingFlagBits::eResuming : return "Resuming";
case RenderingFlagBits::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT";
case RenderingFlagBits::eContentsInlineKHR : return "ContentsInlineKHR";
case RenderingFlagBits::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
@ -6912,6 +6932,7 @@ namespace VULKAN_HPP_NAMESPACE
case PipelineCreateFlagBits2::eDisallowOpacityMicromapARM : return "DisallowOpacityMicromapARM";
case PipelineCreateFlagBits2::eCaptureDataKHR : return "CaptureDataKHR";
case PipelineCreateFlagBits2::eIndirectBindableEXT : return "IndirectBindableEXT";
case PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
@ -9468,8 +9489,6 @@ namespace VULKAN_HPP_NAMESPACE
case ComponentTypeKHR::eBfloat16 : return "Bfloat16";
case ComponentTypeKHR::eSint8PackedNV : return "Sint8PackedNV";
case ComponentTypeKHR::eUint8PackedNV : return "Uint8PackedNV";
case ComponentTypeKHR::eFloatE4M3NV : return "FloatE4M3NV";
case ComponentTypeKHR::eFloatE5M2NV : return "FloatE5M2NV";
case ComponentTypeKHR::eFloat8E4M3EXT : return "Float8E4M3EXT";
case ComponentTypeKHR::eFloat8E5M2EXT : return "Float8E5M2EXT";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
@ -9956,6 +9975,16 @@ namespace VULKAN_HPP_NAMESPACE
}
#if defined( VK_USE_PLATFORM_OHOS )
//=== VK_OHOS_surface ===
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCreateFlagBitsOHOS )
{
return "(void)";
}
#endif /*VK_USE_PLATFORM_OHOS*/
} // namespace VULKAN_HPP_NAMESPACE

14
include/vulkan/vulkan_video.cppm
View file

@ -59,6 +59,12 @@ export namespace VULKAN_HPP_NAMESPACE
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;
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;
//===============
//=== STRUCTS ===
@ -94,6 +100,8 @@ export namespace VULKAN_HPP_NAMESPACE
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;
@ -152,6 +160,12 @@ 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;
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;
} // namespace VULKAN_HPP_VIDEO_NAMESPACE
} // namespace VULKAN_HPP_NAMESPACE

447
include/vulkan/vulkan_video.hpp
View file

@ -13,15 +13,15 @@
#include <vk_video/vulkan_video_codec_av1std.h>
#include <vk_video/vulkan_video_codec_av1std_decode.h>
#if ( 301 < VK_HEADER_VERSION )
# include <vk_video/vulkan_video_codec_av1std_encode.h>
#endif
#include <vk_video/vulkan_video_codec_av1std_encode.h>
#include <vk_video/vulkan_video_codec_h264std.h>
#include <vk_video/vulkan_video_codec_h264std_decode.h>
#include <vk_video/vulkan_video_codec_h264std_encode.h>
#include <vk_video/vulkan_video_codec_h265std.h>
#include <vk_video/vulkan_video_codec_h265std_decode.h>
#include <vk_video/vulkan_video_codec_h265std_encode.h>
#include <vk_video/vulkan_video_codec_vp9std.h>
#include <vk_video/vulkan_video_codec_vp9std_decode.h>
#include <vk_video/vulkan_video_codecs_common.h>
#if !defined( VULKAN_HPP_VIDEO_NAMESPACE )
@ -274,6 +274,75 @@ namespace VULKAN_HPP_NAMESPACE
eInvalid = STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID
};
//=== vulkan_video_codec_vp9std ===
enum class VP9Profile
{
e0 = STD_VIDEO_VP9_PROFILE_0,
e1 = STD_VIDEO_VP9_PROFILE_1,
e2 = STD_VIDEO_VP9_PROFILE_2,
e3 = STD_VIDEO_VP9_PROFILE_3,
eInvalid = STD_VIDEO_VP9_PROFILE_INVALID
};
enum class VP9Level
{
e1_0 = STD_VIDEO_VP9_LEVEL_1_0,
e1_1 = STD_VIDEO_VP9_LEVEL_1_1,
e2_0 = STD_VIDEO_VP9_LEVEL_2_0,
e2_1 = STD_VIDEO_VP9_LEVEL_2_1,
e3_0 = STD_VIDEO_VP9_LEVEL_3_0,
e3_1 = STD_VIDEO_VP9_LEVEL_3_1,
e4_0 = STD_VIDEO_VP9_LEVEL_4_0,
e4_1 = STD_VIDEO_VP9_LEVEL_4_1,
e5_0 = STD_VIDEO_VP9_LEVEL_5_0,
e5_1 = STD_VIDEO_VP9_LEVEL_5_1,
e5_2 = STD_VIDEO_VP9_LEVEL_5_2,
e6_0 = STD_VIDEO_VP9_LEVEL_6_0,
e6_1 = STD_VIDEO_VP9_LEVEL_6_1,
e6_2 = STD_VIDEO_VP9_LEVEL_6_2,
eInvalid = STD_VIDEO_VP9_LEVEL_INVALID
};
enum class VP9FrameType
{
eKey = STD_VIDEO_VP9_FRAME_TYPE_KEY,
eNonKey = STD_VIDEO_VP9_FRAME_TYPE_NON_KEY,
eInvalid = STD_VIDEO_VP9_FRAME_TYPE_INVALID
};
enum class VP9ReferenceName
{
eIntraFrame = STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME,
eLastFrame = STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME,
eGoldenFrame = STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME,
eAltrefFrame = STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME,
eInvalid = STD_VIDEO_VP9_REFERENCE_NAME_INVALID
};
enum class VP9InterpolationFilter
{
eEighttap = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP,
eEighttapSmooth = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH,
eEighttapSharp = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP,
eBilinear = STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR,
eSwitchable = STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE,
eInvalid = STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID
};
enum class VP9ColorSpace
{
eUnknown = STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN,
eBt601 = STD_VIDEO_VP9_COLOR_SPACE_BT_601,
eBt709 = STD_VIDEO_VP9_COLOR_SPACE_BT_709,
eSmpte170 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170,
eSmpte240 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240,
eBt2020 = STD_VIDEO_VP9_COLOR_SPACE_BT_2020,
eReserved = STD_VIDEO_VP9_COLOR_SPACE_RESERVED,
eRgb = STD_VIDEO_VP9_COLOR_SPACE_RGB,
eInvalid = STD_VIDEO_VP9_COLOR_SPACE_INVALID
};
//=== vulkan_video_codec_av1std ===
enum class AV1Profile
@ -3445,6 +3514,378 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t TemporalId = {};
};
//=== vulkan_video_codec_vp9std ===
struct VP9ColorConfigFlags
{
using NativeType = StdVideoVP9ColorConfigFlags;
operator StdVideoVP9ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoVP9ColorConfigFlags *>( this );
}
operator StdVideoVP9ColorConfigFlags &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoVP9ColorConfigFlags *>( this );
}
operator StdVideoVP9ColorConfigFlags const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const StdVideoVP9ColorConfigFlags *>( this );
}
operator StdVideoVP9ColorConfigFlags *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<StdVideoVP9ColorConfigFlags *>( this );
}
bool operator==( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( color_range == rhs.color_range ) && ( reserved == rhs.reserved );
}
bool operator!=( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
uint32_t color_range : 1;
uint32_t reserved : 31;
};
struct VP9ColorConfig
{
using NativeType = StdVideoVP9ColorConfig;
operator StdVideoVP9ColorConfig const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoVP9ColorConfig *>( this );
}
operator StdVideoVP9ColorConfig &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoVP9ColorConfig *>( this );
}
operator StdVideoVP9ColorConfig const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const StdVideoVP9ColorConfig *>( this );
}
operator StdVideoVP9ColorConfig *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<StdVideoVP9ColorConfig *>( this );
}
bool operator==( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) &&
( reserved1 == rhs.reserved1 ) && ( color_space == rhs.color_space );
}
bool operator!=( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags flags = {};
uint8_t BitDepth = {};
uint8_t subsampling_x = {};
uint8_t subsampling_y = {};
uint8_t reserved1 = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace color_space = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace::eUnknown;
};
struct VP9LoopFilterFlags
{
using NativeType = StdVideoVP9LoopFilterFlags;
operator StdVideoVP9LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoVP9LoopFilterFlags *>( this );
}
operator StdVideoVP9LoopFilterFlags &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoVP9LoopFilterFlags *>( this );
}
operator StdVideoVP9LoopFilterFlags const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const StdVideoVP9LoopFilterFlags *>( this );
}
operator StdVideoVP9LoopFilterFlags *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<StdVideoVP9LoopFilterFlags *>( this );
}
bool operator==( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) &&
( reserved == rhs.reserved );
}
bool operator!=( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
uint32_t loop_filter_delta_enabled : 1;
uint32_t loop_filter_delta_update : 1;
uint32_t reserved : 30;
};
struct VP9LoopFilter
{
using NativeType = StdVideoVP9LoopFilter;
operator StdVideoVP9LoopFilter const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoVP9LoopFilter *>( this );
}
operator StdVideoVP9LoopFilter &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoVP9LoopFilter *>( this );
}
operator StdVideoVP9LoopFilter const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const StdVideoVP9LoopFilter *>( this );
}
operator StdVideoVP9LoopFilter *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<StdVideoVP9LoopFilter *>( this );
}
bool operator==( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) &&
( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) &&
( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas );
}
bool operator!=( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags flags = {};
uint8_t loop_filter_level = {};
uint8_t loop_filter_sharpness = {};
uint8_t update_ref_delta = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_VP9_MAX_REF_FRAMES> loop_filter_ref_deltas = {};
uint8_t update_mode_delta = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS> loop_filter_mode_deltas = {};
};
struct VP9SegmentationFlags
{
using NativeType = StdVideoVP9SegmentationFlags;
operator StdVideoVP9SegmentationFlags const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoVP9SegmentationFlags *>( this );
}
operator StdVideoVP9SegmentationFlags &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoVP9SegmentationFlags *>( this );
}
operator StdVideoVP9SegmentationFlags const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const StdVideoVP9SegmentationFlags *>( this );
}
operator StdVideoVP9SegmentationFlags *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<StdVideoVP9SegmentationFlags *>( this );
}
bool operator==( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( segmentation_update_map == rhs.segmentation_update_map ) && ( segmentation_temporal_update == rhs.segmentation_temporal_update ) &&
( segmentation_update_data == rhs.segmentation_update_data ) && ( segmentation_abs_or_delta_update == rhs.segmentation_abs_or_delta_update ) &&
( reserved == rhs.reserved );
}
bool operator!=( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
uint32_t segmentation_update_map : 1;
uint32_t segmentation_temporal_update : 1;
uint32_t segmentation_update_data : 1;
uint32_t segmentation_abs_or_delta_update : 1;
uint32_t reserved : 28;
};
struct VP9Segmentation
{
using NativeType = StdVideoVP9Segmentation;
operator StdVideoVP9Segmentation const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoVP9Segmentation *>( this );
}
operator StdVideoVP9Segmentation &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoVP9Segmentation *>( this );
}
operator StdVideoVP9Segmentation const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const StdVideoVP9Segmentation *>( this );
}
operator StdVideoVP9Segmentation *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<StdVideoVP9Segmentation *>( this );
}
bool operator==( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( flags == rhs.flags ) && ( segmentation_tree_probs == rhs.segmentation_tree_probs ) &&
( segmentation_pred_prob == rhs.segmentation_pred_prob ) && ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData );
}
bool operator!=( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags flags = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS> segmentation_tree_probs = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB> segmentation_pred_prob = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTS> FeatureEnabled = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int16_t, STD_VIDEO_VP9_MAX_SEGMENTS, STD_VIDEO_VP9_SEG_LVL_MAX> FeatureData = {};
};
//=== vulkan_video_codec_vp9std_decode ===
struct DecodeVP9PictureInfoFlags
{
using NativeType = StdVideoDecodeVP9PictureInfoFlags;
operator StdVideoDecodeVP9PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoDecodeVP9PictureInfoFlags *>( this );
}
operator StdVideoDecodeVP9PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoDecodeVP9PictureInfoFlags *>( this );
}
operator StdVideoDecodeVP9PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const StdVideoDecodeVP9PictureInfoFlags *>( this );
}
operator StdVideoDecodeVP9PictureInfoFlags *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<StdVideoDecodeVP9PictureInfoFlags *>( this );
}
bool operator==( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( error_resilient_mode == rhs.error_resilient_mode ) && ( intra_only == rhs.intra_only ) &&
( allow_high_precision_mv == rhs.allow_high_precision_mv ) && ( refresh_frame_context == rhs.refresh_frame_context ) &&
( frame_parallel_decoding_mode == rhs.frame_parallel_decoding_mode ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
( show_frame == rhs.show_frame ) && ( UsePrevFrameMvs == rhs.UsePrevFrameMvs ) && ( reserved == rhs.reserved );
}
bool operator!=( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
uint32_t error_resilient_mode : 1;
uint32_t intra_only : 1;
uint32_t allow_high_precision_mv : 1;
uint32_t refresh_frame_context : 1;
uint32_t frame_parallel_decoding_mode : 1;
uint32_t segmentation_enabled : 1;
uint32_t show_frame : 1;
uint32_t UsePrevFrameMvs : 1;
uint32_t reserved : 24;
};
struct DecodeVP9PictureInfo
{
using NativeType = StdVideoDecodeVP9PictureInfo;
operator StdVideoDecodeVP9PictureInfo const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const StdVideoDecodeVP9PictureInfo *>( this );
}
operator StdVideoDecodeVP9PictureInfo &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<StdVideoDecodeVP9PictureInfo *>( this );
}
operator StdVideoDecodeVP9PictureInfo const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const StdVideoDecodeVP9PictureInfo *>( this );
}
operator StdVideoDecodeVP9PictureInfo *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<StdVideoDecodeVP9PictureInfo *>( this );
}
bool operator==( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return ( flags == rhs.flags ) && ( profile == rhs.profile ) && ( frame_type == rhs.frame_type ) && ( frame_context_idx == rhs.frame_context_idx ) &&
( reset_frame_context == rhs.reset_frame_context ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) &&
( ref_frame_sign_bias_mask == rhs.ref_frame_sign_bias_mask ) && ( interpolation_filter == rhs.interpolation_filter ) &&
( base_q_idx == rhs.base_q_idx ) && ( delta_q_y_dc == rhs.delta_q_y_dc ) && ( delta_q_uv_dc == rhs.delta_q_uv_dc ) &&
( delta_q_uv_ac == rhs.delta_q_uv_ac ) && ( tile_cols_log2 == rhs.tile_cols_log2 ) && ( tile_rows_log2 == rhs.tile_rows_log2 ) &&
( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pLoopFilter == rhs.pLoopFilter ) &&
( pSegmentation == rhs.pSegmentation );
}
bool operator!=( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags flags = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile::e0;
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType::eKey;
uint8_t frame_context_idx = {};
uint8_t reset_frame_context = {};
uint8_t refresh_frame_flags = {};
uint8_t ref_frame_sign_bias_mask = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter interpolation_filter =
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter::eEighttap;
uint8_t base_q_idx = {};
int8_t delta_q_y_dc = {};
int8_t delta_q_uv_dc = {};
int8_t delta_q_uv_ac = {};
uint8_t tile_cols_log2 = {};
uint8_t tile_rows_log2 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, 3> reserved1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig * pColorConfig = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter * pLoopFilter = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation * pSegmentation = {};
};
//=== vulkan_video_codec_av1std ===
struct AV1ColorConfigFlags

7
registry/base_generator.py
View file

@ -447,13 +447,16 @@ class BaseGenerator(OutputGenerator):
deprecatedby = interface.get('deprecatedby')
obsoletedby = interface.get('obsoletedby')
specialuse = splitIfGet(interface, 'specialuse')
ratifiedApis = splitIfGet(interface, 'ratified')
ratified = True if ratifiedApis is not None and self.genOpts.apiname in ratifiedApis else False
# Not sure if better way to get this info
specVersion = self.featureDictionary[name]['enumconstant'][None][None][0]
nameString = self.featureDictionary[name]['enumconstant'][None][None][1]
self.currentExtension = Extension(name, nameString, specVersion, instance, device, depends, vendorTag,
platform, protect, provisional, promotedto, deprecatedby,
obsoletedby, specialuse)
obsoletedby, specialuse, ratified)
self.vk.extensions[name] = self.currentExtension
else: # version
number = interface.get('number')
@ -667,7 +670,7 @@ class BaseGenerator(OutputGenerator):
length = None if length == 'null-terminated' else length
cdecl = self.makeCParamDecl(member, 0)
fullType = ' '.join(cdecl.split()[:-1])
fullType = ' '.join(cdecl[:cdecl.rfind(name)].split())
pointer = '*' in cdecl or type.startswith('PFN_')
const = 'const' in cdecl
# Some structs like VkTransformMatrixKHR have a 2D array

263
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

108
registry/vk.xml
View file

@ -35,6 +35,7 @@ branch of the member gitlab server.
<platform name="sci" protect="VK_USE_PLATFORM_SCI" comment="NVIDIA SCI"/>
<platform name="provisional" protect="VK_ENABLE_BETA_EXTENSIONS" comment="Enable declarations for beta/provisional extensions"/>
<platform name="screen" protect="VK_USE_PLATFORM_SCREEN_QNX" comment="QNX Screen Graphics Subsystem"/>
<platform name="ohos" protect="VK_USE_PLATFORM_OHOS" comment="Open Harmony OS"/>
</platforms>
<tags comment="Vulkan vendor/author tags for extensions and layers">
@ -70,6 +71,7 @@ branch of the member gitlab server.
<tag name="MESA" author="Mesa open source project" contact="Lina Versace @linyaa-kiwi, Daniel Stone @fooishbar, David Airlie @airlied, Faith Ekstrand @gfxstrand, Hans-Kristian Arntzen @HansKristian-Work"/>
<tag name="INTEL" author="Intel Corporation" contact="Slawek Grajewski @sgrajewski"/>
<tag name="HUAWEI" author="Huawei Technologies Co. Ltd." contact="Pan Gao @PanGao-h, Juntao Li @Lawrenceleehw"/>
<tag name="OHOS" author="Huawei Technologies Co. Ltd." contact="Weilan Chen @wchen-h"/>
<tag name="VALVE" author="Valve Corporation" contact="Pierre-Loup Griffais @plagman, Joshua Ashton @Joshua-Ashton, Hans-Kristian Arntzen @HansKristian-Work"/>
<tag name="QNX" author="BlackBerry Limited" contact="Mike Gorchak @mgorchak-blackberry, Aaron Ruby @aruby-blackberry"/>
<tag name="JUICE" author="Juice Technologies, Inc." contact="David McCloskey @damcclos, Dean Beeler @canadacow"/>
@ -179,7 +181,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> 317</type>
#define <name>VK_HEADER_VERSION</name> 318</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
@ -278,6 +280,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="basetype">typedef <type>uint64_t</type> <name>VkDeviceSize</name>;</type>
<type category="basetype">typedef <type>uint64_t</type> <name>VkDeviceAddress</name>;</type>
<type category="basetype">typedef struct NativeWindow <name>OHNativeWindow</name>;</type>
<comment>Basic C types, pulled in via vk_platform.h</comment>
<type requires="vk_platform" name="void"/>
<type requires="vk_platform" name="char"/>
@ -502,6 +506,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type requires="VkShaderCreateFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkShaderCreateFlagsEXT</name>;</type>
<type requires="VkTileShadingRenderPassFlagBitsQCOM" category="bitmask">typedef <type>VkFlags</type> <name>VkTileShadingRenderPassFlagsQCOM</name>;</type>
<type bitvalues="VkPhysicalDeviceSchedulingControlsFlagBitsARM" category="bitmask">typedef <type>VkFlags64</type> <name>VkPhysicalDeviceSchedulingControlsFlagsARM</name>;</type>
<type category="bitmask">typedef <type>VkFlags</type> <name>VkSurfaceCreateFlagsOHOS</name>;</type>
<comment>Video Core extension</comment>
<type requires="VkVideoCodecOperationFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCodecOperationFlagsKHR</name>;</type>
@ -4047,7 +4052,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>VkBool32</type> <name>earlyFragmentMultisampleCoverageAfterSampleCounting</name></member>
<member limittype="max"><type>VkBool32</type> <name>earlyFragmentSampleMaskTestBeforeSampleCounting</name></member>
<member limittype="max"><type>VkBool32</type> <name>depthStencilSwizzleOneSupport</name></member>
<member limittype="max"><type>VkBool32</type> <name>polygonModePointSize</name></member>
<member limittype="exact"><type>VkBool32</type> <name>polygonModePointSize</name></member>
<member limittype="max"><type>VkBool32</type> <name>nonStrictSinglePixelWideLinesUseParallelogram</name></member>
<member limittype="max"><type>VkBool32</type> <name>nonStrictWideLinesUseParallelogram</name></member>
</type>
@ -6095,7 +6100,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member limittype="max"><type>VkBool32</type> <name>earlyFragmentMultisampleCoverageAfterSampleCounting</name></member>
<member limittype="max"><type>VkBool32</type> <name>earlyFragmentSampleMaskTestBeforeSampleCounting</name></member>
<member limittype="max"><type>VkBool32</type> <name>depthStencilSwizzleOneSupport</name></member>
<member limittype="max"><type>VkBool32</type> <name>polygonModePointSize</name></member>
<member limittype="exact"><type>VkBool32</type> <name>polygonModePointSize</name></member>
<member limittype="max"><type>VkBool32</type> <name>nonStrictSinglePixelWideLinesUseParallelogram</name></member>
<member limittype="max"><type>VkBool32</type> <name>nonStrictWideLinesUseParallelogram</name></member>
<member><type>VkBool32</type> <name>blockTexelViewCompatibleMultipleLayers</name></member>
@ -6132,7 +6137,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>uint32_t</type> <name>faultCount</name></member>
<member optional="true" len="faultCount"><type>VkFaultData</type>*<name>pFaults</name></member>
<member optional="true" len="faultCount"><type>VkFaultData</type>* <name>pFaults</name></member>
<member><type>PFN_vkFaultCallbackFunction</type> <name>pfnFaultCallback</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceToolProperties" returnedonly="true">
@ -6597,13 +6602,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
</type>
<type category="struct" name="VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>*<name>pNext</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>clustercullingShader</name></member>
<member><type>VkBool32</type> <name>multiviewClusterCullingShader</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI" structextends="VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>*<name>pNext</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>clusterShadingRate</name></member>
</type>
<type category="struct" name="VkBufferCopy2">
@ -10358,6 +10363,21 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE" returnedonly="true" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="max"><type>uint32_t</type> <name>maxFragmentDensityMapLayers</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE" returnedonly="true" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>fragmentDensityMapLayered</name></member>
</type>
<type category="struct" name="VkPipelineFragmentDensityMapLayeredCreateInfoVALVE" structextends="VkGraphicsPipelineCreateInfo">
<member values="VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>uint32_t</type> <name>maxFragmentDensityMapLayers</name></member>
</type>
<type category="struct" name="VkSetPresentConfigNV" structextends="VkPresentInfoKHR">
<member values="VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
@ -10507,9 +10527,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_TENSOR_COPY_ARM"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>uint32_t</type> <name>dimensionCount</name></member>
<member optional="true" len="dimensionCount">const <type>uint64_t</type>*<name>pSrcOffset</name></member>
<member optional="true" len="dimensionCount">const <type>uint64_t</type>*<name>pDstOffset</name></member>
<member optional="true" len="dimensionCount">const <type>uint64_t</type>*<name>pExtent</name></member>
<member optional="true" len="dimensionCount">const <type>uint64_t</type>* <name>pSrcOffset</name></member>
<member optional="true" len="dimensionCount">const <type>uint64_t</type>* <name>pDstOffset</name></member>
<member optional="true" len="dimensionCount">const <type>uint64_t</type>* <name>pExtent</name></member>
</type>
<type category="struct" name="VkMemoryDedicatedAllocateInfoTensorARM" structextends="VkMemoryAllocateInfo">
<member values="VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM"><type>VkStructureType</type> <name>sType</name></member>
@ -10518,10 +10538,10 @@ typedef void* <name>MTLSharedEvent_id</name>;
</type>
<type category="struct" name="VkPhysicalDeviceDescriptorBufferTensorPropertiesARM" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>size_t</type> <name>tensorCaptureReplayDescriptorDataSize</name></member>
<member><type>size_t</type> <name>tensorViewCaptureReplayDescriptorDataSize</name></member>
<member><type>size_t</type> <name>tensorDescriptorSize</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member limittype="noauto"><type>size_t</type> <name>tensorCaptureReplayDescriptorDataSize</name></member>
<member limittype="noauto"><type>size_t</type> <name>tensorViewCaptureReplayDescriptorDataSize</name></member>
<member limittype="max"><type>size_t</type> <name>tensorDescriptorSize</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceDescriptorBufferTensorFeaturesARM" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM"><type>VkStructureType</type> <name>sType</name></member>
@ -10572,6 +10592,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkBool32</type> <name>shaderFloat8</name></member>
<member><type>VkBool32</type> <name>shaderFloat8CooperativeMatrix</name></member>
</type>
<type category="struct" name="VkOHSurfaceCreateInfoOHOS">
<member values="VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>VkSurfaceCreateFlagsOHOS</type> <name>flags</name></member>
<member noautovalidity="true"><type>OHNativeWindow</type>* <name>window</name></member>
</type>
<type category="struct" name="VkSurfaceCreateInfoOHOS" alias="VkOHSurfaceCreateInfoOHOS"/>
</types>
@ -13935,6 +13962,13 @@ typedef void* <name>MTLSharedEvent_id</name>;
<param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
<param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
</command>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_SURFACE_LOST_KHR">
<proto><type>VkResult</type> <name>vkCreateSurfaceOHOS</name></proto>
<param><type>VkInstance</type> <name>instance</name></param>
<param>const <type>VkSurfaceCreateInfoOHOS</type>* <name>pCreateInfo</name></param>
<param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
<param><type>VkSurfaceKHR</type>* <name>pSurface</name></param>
</command>
<command successcodes="VK_SUCCESS,VK_INCOMPLETE" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
<proto><type>VkResult</type> <name>vkGetPhysicalDeviceDisplayPropertiesKHR</name></proto>
<param><type>VkPhysicalDevice</type> <name>physicalDevice</name></param>
@ -15722,7 +15756,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
</command>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
<proto><type>VkResult</type> <name>vkQueueSetPerformanceConfigurationINTEL</name></proto>
<param><type>VkQueue</type> <name>queue</name></param>
<param externsync="true"><type>VkQueue</type> <name>queue</name></param>
<param><type>VkPerformanceConfigurationINTEL</type> <name>configuration</name></param>
</command>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_TOO_MANY_OBJECTS,VK_ERROR_OUT_OF_HOST_MEMORY">
@ -20338,7 +20372,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum extends="VkDescriptorUpdateTemplateType" name="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR" alias="VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS" comment="Create descriptor update template for pushed descriptor updates"/>
</require>
</extension>
<extension name="VK_EXT_conditional_rendering" number="82" type="device" author="NV" contact="Vikram Kushwaha @vkushwaha" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan">
<extension name="VK_EXT_conditional_rendering" number="82" type="device" author="NV" contact="Vikram Kushwaha @vkushwaha" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan" ratified="vulkan">
<require>
<enum value="2" name="VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_conditional_rendering&quot;" name="VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME"/>
@ -26246,6 +26280,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<require>
<enum value="0" name="VK_AMD_EXTENSION_479_SPEC_VERSION"/>
<enum value="&quot;VK_AMD_extension_479&quot;" name="VK_AMD_EXTENSION_479_EXTENSION_NAME"/>
<enum bitpos="33" extends="VkBufferUsageFlagBits2" name="VK_BUFFER_USAGE_2_RESERVED_33_AMD"/>
</require>
</extension>
<extension name="VK_KHR_present_id2" number="480" author="KHR" contact="Daniel Stone" type="device" depends="VK_KHR_get_surface_capabilities2+VK_KHR_surface+VK_KHR_swapchain" supported="vulkan" ratified="vulkan">
@ -26569,8 +26604,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV"/>
<enum offset="0" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_SINT8_PACKED_NV"/>
<enum offset="1" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_UINT8_PACKED_NV"/>
<enum offset="2" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT_E4M3_NV"/>
<enum offset="3" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT_E5M2_NV"/>
<enum extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT_E4M3_NV" alias="VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT"/>
<enum extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT_E5M2_NV" alias="VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT"/>
<enum bitpos="44" extends="VkPipelineStageFlagBits2" name="VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV"/>
<type name="VkPhysicalDeviceCooperativeVectorPropertiesNV"/>
<type name="VkPhysicalDeviceCooperativeVectorFeaturesNV"/>
@ -26755,6 +26790,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="47" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_47_BIT_EXT"/>
<enum bitpos="48" extends="VkAccessFlagBits2" name="VK_ACCESS_2_RESERVED_48_BIT_EXT"/>
<enum bitpos="48" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_48_BIT_EXT"/>
<enum bitpos="29" extends="VkBufferUsageFlagBits2" name="VK_BUFFER_USAGE_2_RESERVED_29_BIT_EXT"/>
</require>
</extension>
<extension name="VK_EXT_extension_509" number="509" author="EXT" contact="Kevin Petit @kpet" type="device" supported="disabled">
@ -27449,8 +27485,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="shaderFloat8" struct="VkPhysicalDeviceShaderFloat8FeaturesEXT"/>
</require>
<require depends="VK_KHR_cooperative_matrix">
<enum offset="0" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT"/>
<enum offset="1" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT"/>
<enum offset="2" extnumber="492" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT"/>
<enum offset="3" extnumber="492" extends="VkComponentTypeKHR" name="VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT"/>
</require>
</extension>
<extension name="VK_NV_ray_tracing_validation" number="569" type="device" author="NV" contact="Vikram Kushwaha @vkushwaha-nv" supported="vulkan">
@ -27767,10 +27803,16 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type name="VkVideoDecodeAV1InlineSessionParametersInfoKHR"/>
</require>
</extension>
<extension name="VK_HUAWEI_extension_588" number="588" author="HUAWEI" contact="Pan Gao @pangao-h" supported="disabled">
<extension name="VK_OHOS_surface" number="588" type="instance" depends="VK_KHR_surface" platform="ohos" author="HUAWEI" contact="Weilan Chen @wchen-h" supported="vulkan" nofeatures="true">
<require>
<enum value="0" name="VK_HUAWEI_EXTENSION_588_SPEC_VERSION"/>
<enum value="&quot;VK_HUAWEI_extension_588&quot;" name="VK_HUAWEI_EXTENSION_588_EXTENSION_NAME"/>
<enum value="1" name="VK_OHOS_SURFACE_SPEC_VERSION"/>
<enum value="&quot;VK_OHOS_surface&quot;" name="VK_OHOS_SURFACE_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS"/>
<type name="VkSurfaceCreateFlagsOHOS"/>
<type name="VkOHSurfaceCreateInfoOHOS"/>
<type name="VkSurfaceCreateInfoOHOS"/>
<type name="OHNativeWindow"/>
<command name="vkCreateSurfaceOHOS"/>
</require>
</extension>
<extension name="VK_HUAWEI_extension_589" number="589" author="HUAWEI" contact="Pan Gao @pangao-h" supported="disabled">
@ -27965,13 +28007,20 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_NV_extension_611&quot;" name="VK_NV_EXTENSION_611_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_VALVE_extension_612" number="612" author="EXT" contact="Mike Blumenkrantz @zmike" supported="disabled">
<extension name="VK_VALVE_fragment_density_map_layered" number="612" type="device" depends="(VK_KHR_maintenance5,VK_VERSION_1_4)+VK_EXT_fragment_density_map" author="VALVE" contact="Connor Abbott @cwabbott0" supported="vulkan">
<require>
<enum value="0" name="VK_VALVE_EXTENSION_612_SPEC_VERSION"/>
<enum value="&quot;VK_VALVE_extension_612&quot;" name="VK_VALVE_EXTENSION_612_EXTENSION_NAME"/>
<enum bitpos="2" extends="VkRenderPassCreateFlagBits" name="VK_RENDER_PASS_CREATE_RESERVED_2_BIT_VALVE"/>
<enum bitpos="5" extends="VkRenderingFlagBits" name="VK_RENDERING_RESERVED_5_BIT_VALVE"/>
<enum bitpos="40" extends="VkPipelineCreateFlagBits2" name="VK_PIPELINE_CREATE_2_RESERVED_40_BIT_VALVE"/>
<enum value="1" name="VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION"/>
<enum value="&quot;VK_VALVE_fragment_density_map_layered&quot;" name="VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE"/>
<enum bitpos="2" extends="VkRenderPassCreateFlagBits" name="VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE"/>
<enum bitpos="5" extends="VkRenderingFlagBits" name="VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE"/>
<enum bitpos="40" extends="VkPipelineCreateFlagBits2" name="VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE"/>
<type name="VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE"/>
<type name="VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE"/>
<type name="VkPipelineFragmentDensityMapLayeredCreateInfoVALVE"/>
<feature name="fragmentDensityMapLayered" struct="VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE"/>
</require>
</extension>
<extension name="VK_KHR_robustness2" number="613" author="KHR" type="device" contact="Piers Daniell @pdaniell-nv" depends="VK_KHR_get_physical_device_properties2,VK_VERSION_1_1" supported="vulkan" ratified="vulkan">
@ -28125,6 +28174,9 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum bitpos="53" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_53_BIT_KHR"/>
<enum bitpos="54" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_54_BIT_KHR"/>
<enum bitpos="55" extends="VkFormatFeatureFlagBits2" name="VK_FORMAT_FEATURE_2_RESERVED_55_BIT_KHR"/>
<enum bitpos="1" extends="VkAttachmentDescriptionFlagBits" name="VK_ATTACHMENT_DESCRIPTION_RESERVED_1_BIT_KHR"/>
<enum bitpos="2" extends="VkAttachmentDescriptionFlagBits" name="VK_ATTACHMENT_DESCRIPTION_RESERVED_2_BIT_KHR"/>
<enum bitpos="8" extends="VkRenderingFlagBits" name="VK_RENDERING_RESERVED_8_BIT_KHR"/>
</require>
</extension>
<extension name="VK_ARM_extension_632" number="632" author="ARM" contact="Kevin Petit @kpet" supported="disabled">

1
registry/vulkan_object.py
View file

@ -27,6 +27,7 @@ class Extension:
deprecatedBy: (str | None)
obsoletedBy: (str | None)
specialUse: list[str]
ratified: bool
# These are here to allow for easy reverse lookups
# To prevent infinite recursion, other classes reference a string back to the Extension class