eden-emu/Vulkan-Headers
14
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Headers.git synced 2025-05-11 22:18:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Update for Vulkan-Docs 1.4.313
Some checks failed
ci / cmake-unix (3.22.1, macos-latest) (push) Has been cancelled
Details
ci / cmake-unix (3.22.1, ubuntu-latest) (push) Has been cancelled
Details
ci / cmake-unix (latest, macos-latest) (push) Has been cancelled
Details
ci / cmake-unix (latest, ubuntu-latest) (push) Has been cancelled
Details
ci / cmake-windows (3.22.1) (push) Has been cancelled
Details
ci / cmake-windows (latest) (push) Has been cancelled
Details
ci / windows_clang (clang) (push) Has been cancelled
Details
ci / windows_clang (clang-cl) (push) Has been cancelled
Details
ci / cmake-unix-modules (latest, clang++-18, ubuntu-latest) (push) Has been cancelled
Details
ci / cmake-windows-modules (latest, windows-latest) (push) Has been cancelled
Details
ci / reuse (push) Has been cancelled
Details

Browse source
This commit is contained in:
Jon Leech 2025-04-18 02:27:28 -07:00 • committed by Jon Leech
parent 110b6c989c
commit 409c16be50
16 changed files with 2249 additions and 274 deletions
Download patch file Download diff file Expand all files Collapse all files

23
include/vulkan/vulkan.cppm
View file

@ -2649,6 +2649,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName;
using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion;
//=== VK_QCOM_tile_memory_heap ===
using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapExtensionName;
using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapSpecVersion;
//=== VK_NV_display_stereo ===
using VULKAN_HPP_NAMESPACE::NVDisplayStereoExtensionName;
using VULKAN_HPP_NAMESPACE::NVDisplayStereoSpecVersion;
@ -4698,6 +4702,13 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_descriptor_pool_overallocation ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
//=== VK_QCOM_tile_memory_heap ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM;
using VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM;
using VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM;
using VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM;
//=== VK_NV_display_stereo ===
using VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV;
using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV;
@ -8328,6 +8339,18 @@ export namespace std
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>;
//=== VK_QCOM_tile_memory_heap ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM>;
template <>
struct hash<VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM>;
//=== VK_NV_display_stereo ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV>;

143
include/vulkan/vulkan.hpp
View file

@ -15,30 +15,30 @@
import VULKAN_HPP_STD_MODULE;
#else
# include <algorithm>
# include <array> // ArrayWrapperND
# include <array> // ArrayWrapperND
# include <cassert>
# include <string.h> // strnlen
# include <string> // std::string
# include <utility> // std::exchange
# if 17 <= VULKAN_HPP_CPP_VERSION
# include <string_view>
# endif
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
# include <tuple> // std::tie
# include <vector> // std::vector
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
# include <compare>
# endif
# if !defined( VULKAN_HPP_NO_EXCEPTIONS )
# include <system_error> // std::is_error_code_enum
# endif
# if defined( VULKAN_HPP_SUPPORT_SPAN )
# include <span>
# endif
#endif
#include <vulkan/vulkan.h>
#if 17 <= VULKAN_HPP_CPP_VERSION && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
# include <string_view>
#endif
#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
# include <tuple> // std::tie
# include <vector> // std::vector
#endif
#if !defined( VULKAN_HPP_NO_EXCEPTIONS ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
# include <system_error> // std::is_error_code_enum
#endif
#if ( VULKAN_HPP_ASSERT == assert )
# include <cassert>
#endif
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
# include <dlfcn.h>
@ -55,15 +55,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
# include <compare>
#endif
#if defined( VULKAN_HPP_SUPPORT_SPAN ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 312, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 313, "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)
@ -6112,6 +6104,13 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo );
}
//=== VK_QCOM_tile_memory_heap ===
void vkCmdBindTileMemoryQCOM( VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM * pTileMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
{
return ::vkCmdBindTileMemoryQCOM( commandBuffer, pTileMemoryBindInfo );
}
//=== VK_NV_external_compute_queue ===
VkResult vkCreateExternalComputeQueueNV( VkDevice device,
@ -8625,8 +8624,10 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_displacement_micromap ===
VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapExtensionName = VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapSpecVersion = VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION;
VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." )
VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapSpecVersion = VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
//=== VK_EXT_load_store_op_none ===
@ -8933,6 +8934,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationExtensionName = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationSpecVersion = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION;
//=== VK_QCOM_tile_memory_heap ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapExtensionName = VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapSpecVersion = VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION;
//=== VK_NV_display_stereo ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoExtensionName = VK_NV_DISPLAY_STEREO_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoSpecVersion = VK_NV_DISPLAY_STEREO_SPEC_VERSION;
@ -17376,6 +17381,79 @@ namespace VULKAN_HPP_NAMESPACE
};
};
//=== VK_QCOM_tile_memory_heap ===
template <>
struct StructExtends<PhysicalDeviceTileMemoryHeapFeaturesQCOM, PhysicalDeviceFeatures2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTileMemoryHeapFeaturesQCOM, DeviceCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<PhysicalDeviceTileMemoryHeapPropertiesQCOM, PhysicalDeviceProperties2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<TileMemoryRequirementsQCOM, MemoryRequirements2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<TileMemoryBindInfoQCOM, CommandBufferInheritanceInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<TileMemorySizeInfoQCOM, RenderPassCreateInfo>
{
enum
{
value = true
};
};
template <>
struct StructExtends<TileMemorySizeInfoQCOM, RenderPassCreateInfo2>
{
enum
{
value = true
};
};
template <>
struct StructExtends<TileMemorySizeInfoQCOM, RenderingInfo>
{
enum
{
value = true
};
};
//=== VK_NV_display_stereo ===
template <>
struct StructExtends<DisplaySurfaceStereoCreateInfoNV, DisplaySurfaceCreateInfoKHR>
@ -19484,6 +19562,9 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0;
PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0;
//=== VK_QCOM_tile_memory_heap ===
PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0;
//=== VK_NV_external_compute_queue ===
PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0;
PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0;
@ -21033,6 +21114,9 @@ namespace VULKAN_HPP_NAMESPACE
vkCmdBindDescriptorBufferEmbeddedSamplers2EXT =
PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );
//=== VK_QCOM_tile_memory_heap ===
vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetInstanceProcAddr( instance, "vkCmdBindTileMemoryQCOM" ) );
//=== VK_NV_external_compute_queue ===
vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkCreateExternalComputeQueueNV" ) );
vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkDestroyExternalComputeQueueNV" ) );
@ -22219,6 +22303,9 @@ namespace VULKAN_HPP_NAMESPACE
vkCmdBindDescriptorBufferEmbeddedSamplers2EXT =
PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );
//=== VK_QCOM_tile_memory_heap ===
vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) );
//=== VK_NV_external_compute_queue ===
vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) );
vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) );

56
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 312
#define VK_HEADER_VERSION 313
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -1168,6 +1168,11 @@ typedef enum VkStructureType {
VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007,
VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM = 1000547000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM = 1000547001,
VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM = 1000547002,
VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM = 1000547003,
VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM = 1000547004,
VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV = 1000551000,
VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV = 1000551001,
VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553000,
@ -2565,6 +2570,7 @@ typedef enum VkImageUsageFlagBits {
VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000,
VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000,
VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000,
VK_IMAGE_USAGE_TILE_MEMORY_QCOM = 0x08000000,
VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000,
VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000,
VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
@ -2582,6 +2588,7 @@ typedef VkFlags VkInstanceCreateFlags;
typedef enum VkMemoryHeapFlagBits {
VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM = 0x00000008,
VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkMemoryHeapFlagBits;
@ -2767,6 +2774,7 @@ typedef enum VkBufferUsageFlagBits {
VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000,
VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000,
VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000,
VK_BUFFER_USAGE_TILE_MEMORY_QCOM = 0x08000000,
VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,
VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
@ -7966,6 +7974,7 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM = 0x08000000ULL;
static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ULL;
@ -20633,6 +20642,51 @@ typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
// VK_QCOM_tile_memory_heap is a preprocessor guard. Do not pass it to API calls.
#define VK_QCOM_tile_memory_heap 1
#define VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION 1
#define VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME "VK_QCOM_tile_memory_heap"
typedef struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM {
VkStructureType sType;
void* pNext;
VkBool32 tileMemoryHeap;
} VkPhysicalDeviceTileMemoryHeapFeaturesQCOM;
typedef struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM {
VkStructureType sType;
void* pNext;
VkBool32 queueSubmitBoundary;
VkBool32 tileBufferTransfers;
} VkPhysicalDeviceTileMemoryHeapPropertiesQCOM;
typedef struct VkTileMemoryRequirementsQCOM {
VkStructureType sType;
void* pNext;
VkDeviceSize size;
VkDeviceSize alignment;
} VkTileMemoryRequirementsQCOM;
typedef struct VkTileMemoryBindInfoQCOM {
VkStructureType sType;
const void* pNext;
VkDeviceMemory memory;
} VkTileMemoryBindInfoQCOM;
typedef struct VkTileMemorySizeInfoQCOM {
VkStructureType sType;
const void* pNext;
VkDeviceSize size;
} VkTileMemorySizeInfoQCOM;
typedef void (VKAPI_PTR *PFN_vkCmdBindTileMemoryQCOM)(VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR void VKAPI_CALL vkCmdBindTileMemoryQCOM(
VkCommandBuffer commandBuffer,
const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo);
#endif
// VK_NV_display_stereo is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_display_stereo 1
#define VK_NV_DISPLAY_STEREO_SPEC_VERSION 1

262
include/vulkan/vulkan_enums.hpp
View file

File diff suppressed because it is too large Load diff

42
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -69,7 +69,10 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_AMD_gpu_shader_int16", "VK_KHR_shader_float16_int8" },
{ "VK_NV_ray_tracing", "VK_KHR_ray_tracing_pipeline" },
{ "VK_EXT_buffer_device_address", "VK_KHR_buffer_device_address" },
{ "VK_EXT_validation_features", "VK_EXT_layer_settings" }
{ "VK_EXT_validation_features", "VK_EXT_layer_settings" },
#if defined( VK_ENABLE_BETA_EXTENSIONS )
{ "VK_NV_displacement_micromap", "VK_NV_cluster_acceleration_structure" }
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
};
return deprecatedExtensions;
}
@ -449,6 +452,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_shader_expect_assume",
"VK_KHR_maintenance6",
"VK_NV_descriptor_pool_overallocation",
"VK_QCOM_tile_memory_heap",
"VK_KHR_video_encode_quantization_map",
"VK_NV_raw_access_chains",
"VK_NV_external_compute_queue",
@ -2470,6 +2474,13 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } },
{ "VK_QCOM_tile_memory_heap",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_memory_requirements2",
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_NV_display_stereo",
{ { "VK_VERSION_1_0",
{ {
@ -2818,6 +2829,13 @@ namespace VULKAN_HPP_NAMESPACE
{
return "VK_EXT_layer_settings";
}
#if defined( VK_ENABLE_BETA_EXTENSIONS )
if ( extension == "VK_NV_displacement_micromap" )
{
return "VK_NV_cluster_acceleration_structure";
}
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
return "";
}
@ -3261,7 +3279,11 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_MVK_macos_surface" ) ||
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) ||
( extension == "VK_EXT_validation_features" );
( extension == "VK_EXT_validation_features" ) ||
#if defined( VK_ENABLE_BETA_EXTENSIONS )
( extension == "VK_NV_displacement_micromap" ) ||
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
false;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension )
@ -3456,14 +3478,14 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|| ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) ||
( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) ||
( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) ||
( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) ||
( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) ||
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_QCOM_tile_memory_heap" ) ||
( extension == "VK_KHR_video_encode_quantization_map" ) || ( extension == "VK_NV_raw_access_chains" ) ||
( extension == "VK_NV_external_compute_queue" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) ||
( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) ||
( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) ||
( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) ||
( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) ||
( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) ||
( extension == "VK_ARM_pipeline_opacity_micromap" )
#if defined( VK_USE_PLATFORM_METAL_EXT )

28
include/vulkan/vulkan_funcs.hpp
View file

@ -30777,6 +30777,34 @@ namespace VULKAN_HPP_NAMESPACE
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_QCOM_tile_memory_heap ===
// wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM * pTileMemoryBindInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
d.vkCmdBindTileMemoryQCOM( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkTileMemoryBindInfoQCOM *>( pTileMemoryBindInfo ) );
}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
template <typename Dispatch>
VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( Optional<const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM> tileMemoryBindInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkCmdBindTileMemoryQCOM && "Function <vkCmdBindTileMemoryQCOM> requires <VK_QCOM_tile_memory_heap>" );
# endif
d.vkCmdBindTileMemoryQCOM(
m_commandBuffer,
reinterpret_cast<const VkTileMemoryBindInfoQCOM *>( static_cast<const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM *>( tileMemoryBindInfo ) ) );
}
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_NV_external_compute_queue ===
// wrapper function for command vkCreateExternalComputeQueueNV, see

20
include/vulkan/vulkan_handles.hpp
View file

@ -1904,6 +1904,13 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_descriptor_pool_overallocation ===
struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
//=== VK_QCOM_tile_memory_heap ===
struct PhysicalDeviceTileMemoryHeapFeaturesQCOM;
struct PhysicalDeviceTileMemoryHeapPropertiesQCOM;
struct TileMemoryRequirementsQCOM;
struct TileMemoryBindInfoQCOM;
struct TileMemorySizeInfoQCOM;
//=== VK_NV_display_stereo ===
struct DisplaySurfaceStereoCreateInfoNV;
struct DisplayModeStereoPropertiesNV;
@ -7801,6 +7808,19 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_QCOM_tile_memory_heap ===
// wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindTileMemoryQCOM( const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM * pTileMemoryBindInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void bindTileMemoryQCOM( Optional<const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM> tileMemoryBindInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_NV_cluster_acceleration_structure ===
// wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see

69
include/vulkan/vulkan_hash.hpp
View file

@ -13283,6 +13283,35 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM const & physicalDeviceTileMemoryHeapFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.tileMemoryHeap );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM const & physicalDeviceTileMemoryHeapPropertiesQCOM ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.queueSubmitBoundary );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.tileBufferTransfers );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM>
{
@ -17013,6 +17042,46 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM const & tileMemoryBindInfoQCOM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.memory );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM const & tileMemoryRequirementsQCOM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.size );
VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.alignment );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM const & tileMemorySizeInfoQCOM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.sType );
VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.size );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM>
{

4
include/vulkan/vulkan_hpp_macros.hpp
View file

@ -79,11 +79,11 @@
# define __has_include( x ) false
#endif
#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
#if defined( __cpp_lib_three_way_comparison ) && ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
#endif
#if ( 201803 <= __cpp_lib_span )
#if defined( __cpp_lib_span ) && ( 201803 <= __cpp_lib_span )
# define VULKAN_HPP_SUPPORT_SPAN
#endif

25
include/vulkan/vulkan_raii.hpp
View file

@ -1817,6 +1817,9 @@ namespace VULKAN_HPP_NAMESPACE
vkCmdBindDescriptorBufferEmbeddedSamplers2EXT =
PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );
//=== VK_QCOM_tile_memory_heap ===
vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) );
//=== VK_NV_external_compute_queue ===
vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) );
vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) );
@ -2781,6 +2784,9 @@ namespace VULKAN_HPP_NAMESPACE
PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0;
PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0;
//=== VK_QCOM_tile_memory_heap ===
PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0;
//=== VK_NV_external_compute_queue ===
PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0;
PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0;
@ -7879,6 +7885,12 @@ namespace VULKAN_HPP_NAMESPACE
void bindDescriptorBufferEmbeddedSamplers2EXT(
const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT;
//=== VK_QCOM_tile_memory_heap ===
// wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
void bindTileMemoryQCOM( Optional<const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM> tileMemoryBindInfo
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
//=== VK_NV_cluster_acceleration_structure ===
// wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see
@ -27170,6 +27182,19 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( &bindDescriptorBufferEmbeddedSamplersInfo ) );
}
//=== VK_QCOM_tile_memory_heap ===
// wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html
VULKAN_HPP_INLINE void
CommandBuffer::bindTileMemoryQCOM( Optional<const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM> tileMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
{
VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindTileMemoryQCOM && "Function <vkCmdBindTileMemoryQCOM> requires <VK_QCOM_tile_memory_heap>" );
getDispatcher()->vkCmdBindTileMemoryQCOM(
static_cast<VkCommandBuffer>( m_commandBuffer ),
reinterpret_cast<const VkTileMemoryBindInfoQCOM *>( static_cast<const VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM *>( tileMemoryBindInfo ) ) );
}
//=== VK_NV_external_compute_queue ===
// wrapper function for command vkCreateExternalComputeQueueNV, see

34
include/vulkan/vulkan_static_assertions.hpp
View file

@ -7803,6 +7803,40 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>::value,
"PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" );
//=== VK_QCOM_tile_memory_heap ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM ) == sizeof( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM>::value,
"PhysicalDeviceTileMemoryHeapFeaturesQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM>::value,
"PhysicalDeviceTileMemoryHeapPropertiesQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM ) == sizeof( VkTileMemoryRequirementsQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM>::value,
"TileMemoryRequirementsQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM ) == sizeof( VkTileMemoryBindInfoQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM>::value,
"TileMemoryBindInfoQCOM is not nothrow_move_constructible!" );
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM ) == sizeof( VkTileMemorySizeInfoQCOM ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM>::value, "struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM>::value,
"TileMemorySizeInfoQCOM is not nothrow_move_constructible!" );
//=== VK_NV_display_stereo ===
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV ) == sizeof( VkDisplaySurfaceStereoCreateInfoNV ),

561
include/vulkan/vulkan_structs.hpp
View file

@ -107826,6 +107826,236 @@ namespace VULKAN_HPP_NAMESPACE
using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures;
// wrapper struct for struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.html
struct PhysicalDeviceTileMemoryHeapFeaturesQCOM
{
using NativeType = VkPhysicalDeviceTileMemoryHeapFeaturesQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapFeaturesQCOM( VULKAN_HPP_NAMESPACE::Bool32 tileMemoryHeap_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, tileMemoryHeap{ tileMemoryHeap_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapFeaturesQCOM( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceTileMemoryHeapFeaturesQCOM( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceTileMemoryHeapFeaturesQCOM( *reinterpret_cast<PhysicalDeviceTileMemoryHeapFeaturesQCOM const *>( &rhs ) )
{
}
PhysicalDeviceTileMemoryHeapFeaturesQCOM & operator=( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceTileMemoryHeapFeaturesQCOM & operator=( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM & setTileMemoryHeap( VULKAN_HPP_NAMESPACE::Bool32 tileMemoryHeap_ ) VULKAN_HPP_NOEXCEPT
{
tileMemoryHeap = tileMemoryHeap_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>( this );
}
operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>( this );
}
operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>( this );
}
operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>( 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, tileMemoryHeap );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & ) const = default;
#else
bool operator==( PhysicalDeviceTileMemoryHeapFeaturesQCOM 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 ) && ( tileMemoryHeap == rhs.tileMemoryHeap );
# endif
}
bool operator!=( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 tileMemoryHeap = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM>
{
using Type = PhysicalDeviceTileMemoryHeapFeaturesQCOM;
};
// wrapper struct for struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileMemoryHeapPropertiesQCOM.html
struct PhysicalDeviceTileMemoryHeapPropertiesQCOM
{
using NativeType = VkPhysicalDeviceTileMemoryHeapPropertiesQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapPropertiesQCOM( VULKAN_HPP_NAMESPACE::Bool32 queueSubmitBoundary_ = {},
VULKAN_HPP_NAMESPACE::Bool32 tileBufferTransfers_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, queueSubmitBoundary{ queueSubmitBoundary_ }
, tileBufferTransfers{ tileBufferTransfers_ }
{
}
VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapPropertiesQCOM( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
PhysicalDeviceTileMemoryHeapPropertiesQCOM( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: PhysicalDeviceTileMemoryHeapPropertiesQCOM( *reinterpret_cast<PhysicalDeviceTileMemoryHeapPropertiesQCOM const *>( &rhs ) )
{
}
PhysicalDeviceTileMemoryHeapPropertiesQCOM & operator=( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
PhysicalDeviceTileMemoryHeapPropertiesQCOM & operator=( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM &
setQueueSubmitBoundary( VULKAN_HPP_NAMESPACE::Bool32 queueSubmitBoundary_ ) VULKAN_HPP_NOEXCEPT
{
queueSubmitBoundary = queueSubmitBoundary_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM &
setTileBufferTransfers( VULKAN_HPP_NAMESPACE::Bool32 tileBufferTransfers_ ) VULKAN_HPP_NOEXCEPT
{
tileBufferTransfers = tileBufferTransfers_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *>( this );
}
operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *>( this );
}
operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *>( this );
}
operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *>( 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 &, VULKAN_HPP_NAMESPACE::Bool32 const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, queueSubmitBoundary, tileBufferTransfers );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & ) const = default;
#else
bool operator==( PhysicalDeviceTileMemoryHeapPropertiesQCOM 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 ) && ( queueSubmitBoundary == rhs.queueSubmitBoundary ) &&
( tileBufferTransfers == rhs.tileBufferTransfers );
# endif
}
bool operator!=( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM;
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 queueSubmitBoundary = {};
VULKAN_HPP_NAMESPACE::Bool32 tileBufferTransfers = {};
};
template <>
struct CppType<StructureType, StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM>
{
using Type = PhysicalDeviceTileMemoryHeapPropertiesQCOM;
};
// wrapper struct for struct VkPhysicalDeviceTilePropertiesFeaturesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTilePropertiesFeaturesQCOM.html
struct PhysicalDeviceTilePropertiesFeaturesQCOM
@ -140262,6 +140492,337 @@ namespace VULKAN_HPP_NAMESPACE
using Type = TextureLODGatherFormatPropertiesAMD;
};
// wrapper struct for struct VkTileMemoryBindInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemoryBindInfoQCOM.html
struct TileMemoryBindInfoQCOM
{
using NativeType = VkTileMemoryBindInfoQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemoryBindInfoQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR TileMemoryBindInfoQCOM( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, memory{ memory_ }
{
}
VULKAN_HPP_CONSTEXPR TileMemoryBindInfoQCOM( TileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
TileMemoryBindInfoQCOM( VkTileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: TileMemoryBindInfoQCOM( *reinterpret_cast<TileMemoryBindInfoQCOM const *>( &rhs ) )
{
}
TileMemoryBindInfoQCOM & operator=( TileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
TileMemoryBindInfoQCOM & operator=( VkTileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM & setMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory_ ) VULKAN_HPP_NOEXCEPT
{
memory = memory_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkTileMemoryBindInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkTileMemoryBindInfoQCOM *>( this );
}
operator VkTileMemoryBindInfoQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkTileMemoryBindInfoQCOM *>( this );
}
operator VkTileMemoryBindInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkTileMemoryBindInfoQCOM *>( this );
}
operator VkTileMemoryBindInfoQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkTileMemoryBindInfoQCOM *>( 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::DeviceMemory const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, memory );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( TileMemoryBindInfoQCOM const & ) const = default;
#else
bool operator==( TileMemoryBindInfoQCOM 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 ) && ( memory == rhs.memory );
# endif
}
bool operator!=( TileMemoryBindInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTileMemoryBindInfoQCOM;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceMemory memory = {};
};
template <>
struct CppType<StructureType, StructureType::eTileMemoryBindInfoQCOM>
{
using Type = TileMemoryBindInfoQCOM;
};
// wrapper struct for struct VkTileMemoryRequirementsQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemoryRequirementsQCOM.html
struct TileMemoryRequirementsQCOM
{
using NativeType = VkTileMemoryRequirementsQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemoryRequirementsQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR TileMemoryRequirementsQCOM( VULKAN_HPP_NAMESPACE::DeviceSize size_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize alignment_ = {},
void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, size{ size_ }
, alignment{ alignment_ }
{
}
VULKAN_HPP_CONSTEXPR TileMemoryRequirementsQCOM( TileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
TileMemoryRequirementsQCOM( VkTileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: TileMemoryRequirementsQCOM( *reinterpret_cast<TileMemoryRequirementsQCOM const *>( &rhs ) )
{
}
TileMemoryRequirementsQCOM & operator=( TileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
TileMemoryRequirementsQCOM & operator=( VkTileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setSize( VULKAN_HPP_NAMESPACE::DeviceSize size_ ) VULKAN_HPP_NOEXCEPT
{
size = size_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setAlignment( VULKAN_HPP_NAMESPACE::DeviceSize alignment_ ) VULKAN_HPP_NOEXCEPT
{
alignment = alignment_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkTileMemoryRequirementsQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkTileMemoryRequirementsQCOM *>( this );
}
operator VkTileMemoryRequirementsQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkTileMemoryRequirementsQCOM *>( this );
}
operator VkTileMemoryRequirementsQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkTileMemoryRequirementsQCOM *>( this );
}
operator VkTileMemoryRequirementsQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkTileMemoryRequirementsQCOM *>( 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::DeviceSize const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, size, alignment );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( TileMemoryRequirementsQCOM const & ) const = default;
#else
bool operator==( TileMemoryRequirementsQCOM 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 ) && ( size == rhs.size ) && ( alignment == rhs.alignment );
# endif
}
bool operator!=( TileMemoryRequirementsQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTileMemoryRequirementsQCOM;
void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceSize size = {};
VULKAN_HPP_NAMESPACE::DeviceSize alignment = {};
};
template <>
struct CppType<StructureType, StructureType::eTileMemoryRequirementsQCOM>
{
using Type = TileMemoryRequirementsQCOM;
};
// wrapper struct for struct VkTileMemorySizeInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemorySizeInfoQCOM.html
struct TileMemorySizeInfoQCOM
{
using NativeType = VkTileMemorySizeInfoQCOM;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemorySizeInfoQCOM;
#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR TileMemorySizeInfoQCOM( VULKAN_HPP_NAMESPACE::DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
: pNext{ pNext_ }
, size{ size_ }
{
}
VULKAN_HPP_CONSTEXPR TileMemorySizeInfoQCOM( TileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
TileMemorySizeInfoQCOM( VkTileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
: TileMemorySizeInfoQCOM( *reinterpret_cast<TileMemorySizeInfoQCOM const *>( &rhs ) )
{
}
TileMemorySizeInfoQCOM & operator=( TileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
TileMemorySizeInfoQCOM & operator=( VkTileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM const *>( &rhs );
return *this;
}
#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM & setSize( VULKAN_HPP_NAMESPACE::DeviceSize size_ ) VULKAN_HPP_NOEXCEPT
{
size = size_;
return *this;
}
#endif /*VULKAN_HPP_NO_SETTERS*/
operator VkTileMemorySizeInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkTileMemorySizeInfoQCOM *>( this );
}
operator VkTileMemorySizeInfoQCOM &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkTileMemorySizeInfoQCOM *>( this );
}
operator VkTileMemorySizeInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<const VkTileMemorySizeInfoQCOM *>( this );
}
operator VkTileMemorySizeInfoQCOM *() VULKAN_HPP_NOEXCEPT
{
return reinterpret_cast<VkTileMemorySizeInfoQCOM *>( 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::DeviceSize const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, size );
}
#endif
#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( TileMemorySizeInfoQCOM const & ) const = default;
#else
bool operator==( TileMemorySizeInfoQCOM 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 ) && ( size == rhs.size );
# endif
}
bool operator!=( TileMemorySizeInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
#endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eTileMemorySizeInfoQCOM;
const void * pNext = {};
VULKAN_HPP_NAMESPACE::DeviceSize size = {};
};
template <>
struct CppType<StructureType, StructureType::eTileMemorySizeInfoQCOM>
{
using Type = TileMemorySizeInfoQCOM;
};
// wrapper struct for struct VkTilePropertiesQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTilePropertiesQCOM.html
struct TilePropertiesQCOM
{

17
include/vulkan/vulkan_to_string.hpp
View file

@ -207,6 +207,8 @@ namespace VULKAN_HPP_NAMESPACE
result += " SampleWeightQCOM |";
if ( value & ImageUsageFlagBits::eSampleBlockMatchQCOM )
result += " SampleBlockMatchQCOM |";
if ( value & ImageUsageFlagBits::eTileMemoryQCOM )
result += " TileMemoryQCOM |";
if ( value & ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR )
result += " VideoEncodeQuantizationDeltaMapKHR |";
if ( value & ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR )
@ -239,6 +241,8 @@ namespace VULKAN_HPP_NAMESPACE
result += " DeviceLocal |";
if ( value & MemoryHeapFlagBits::eMultiInstance )
result += " MultiInstance |";
if ( value & MemoryHeapFlagBits::eTileMemoryQCOM )
result += " TileMemoryQCOM |";
if ( result.size() > 1 )
result.back() = '}';
@ -663,6 +667,8 @@ namespace VULKAN_HPP_NAMESPACE
result += " MicromapBuildInputReadOnlyEXT |";
if ( value & BufferUsageFlagBits::eMicromapStorageEXT )
result += " MicromapStorageEXT |";
if ( value & BufferUsageFlagBits::eTileMemoryQCOM )
result += " TileMemoryQCOM |";
if ( result.size() > 1 )
result.back() = '}';
@ -2119,6 +2125,8 @@ namespace VULKAN_HPP_NAMESPACE
result += " MicromapBuildInputReadOnlyEXT |";
if ( value & BufferUsageFlagBits2::eMicromapStorageEXT )
result += " MicromapStorageEXT |";
if ( value & BufferUsageFlagBits2::eTileMemoryQCOM )
result += " TileMemoryQCOM |";
if ( value & BufferUsageFlagBits2::ePreprocessBufferEXT )
result += " PreprocessBufferEXT |";
@ -5038,6 +5046,11 @@ namespace VULKAN_HPP_NAMESPACE
case StructureType::eSetDescriptorBufferOffsetsInfoEXT: return "SetDescriptorBufferOffsetsInfoEXT";
case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT: return "BindDescriptorBufferEmbeddedSamplersInfoEXT";
case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV: return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
case StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM: return "PhysicalDeviceTileMemoryHeapFeaturesQCOM";
case StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM: return "PhysicalDeviceTileMemoryHeapPropertiesQCOM";
case StructureType::eTileMemoryRequirementsQCOM: return "TileMemoryRequirementsQCOM";
case StructureType::eTileMemoryBindInfoQCOM: return "TileMemoryBindInfoQCOM";
case StructureType::eTileMemorySizeInfoQCOM: return "TileMemorySizeInfoQCOM";
case StructureType::eDisplaySurfaceStereoCreateInfoNV: return "DisplaySurfaceStereoCreateInfoNV";
case StructureType::eDisplayModeStereoPropertiesNV: return "DisplayModeStereoPropertiesNV";
case StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR: return "VideoEncodeQuantizationMapCapabilitiesKHR";
@ -5594,6 +5607,7 @@ namespace VULKAN_HPP_NAMESPACE
case ImageUsageFlagBits::eInvocationMaskHUAWEI: return "InvocationMaskHUAWEI";
case ImageUsageFlagBits::eSampleWeightQCOM: return "SampleWeightQCOM";
case ImageUsageFlagBits::eSampleBlockMatchQCOM: return "SampleBlockMatchQCOM";
case ImageUsageFlagBits::eTileMemoryQCOM: return "TileMemoryQCOM";
case ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR: return "VideoEncodeQuantizationDeltaMapKHR";
case ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR: return "VideoEncodeEmphasisMapKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
@ -5624,6 +5638,7 @@ namespace VULKAN_HPP_NAMESPACE
{
case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal";
case MemoryHeapFlagBits::eMultiInstance: return "MultiInstance";
case MemoryHeapFlagBits::eTileMemoryQCOM: return "TileMemoryQCOM";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -5935,6 +5950,7 @@ namespace VULKAN_HPP_NAMESPACE
case BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT: return "PushDescriptorsDescriptorBufferEXT";
case BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT: return "MicromapBuildInputReadOnlyEXT";
case BufferUsageFlagBits::eMicromapStorageEXT: return "MicromapStorageEXT";
case BufferUsageFlagBits::eTileMemoryQCOM: return "TileMemoryQCOM";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -7495,6 +7511,7 @@ namespace VULKAN_HPP_NAMESPACE
case BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT: return "PushDescriptorsDescriptorBufferEXT";
case BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT: return "MicromapBuildInputReadOnlyEXT";
case BufferUsageFlagBits2::eMicromapStorageEXT: return "MicromapStorageEXT";
case BufferUsageFlagBits2::eTileMemoryQCOM: return "TileMemoryQCOM";
case BufferUsageFlagBits2::ePreprocessBufferEXT: return "PreprocessBufferEXT";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}

1104
registry/validusage.json
View file

File diff suppressed because one or more lines are too long

20
registry/video.xml
View file

@ -1562,13 +1562,13 @@ The current public version of video.xml is maintained in the default branch
</enums>
<extensions>
<extension name="vulkan_video_codecs_common" comment="protect with VULKAN_VIDEO_CODEC_COMMON_H_" supported="vulkan">
<extension name="vulkan_video_codecs_common" number="1" comment="protect with VULKAN_VIDEO_CODEC_COMMON_H_" supported="vulkan">
<require>
<type name="VK_MAKE_VIDEO_STD_VERSION"/>
<type name="stdint"/>
</require>
</extension>
<extension name="vulkan_video_codec_h264std" comment="protect with VULKAN_VIDEO_CODEC_H264STD_H_" supported="vulkan">
<extension name="vulkan_video_codec_h264std" number="2" comment="protect with VULKAN_VIDEO_CODEC_H264STD_H_" supported="vulkan">
<require>
<type name="vk_video/vulkan_video_codecs_common.h"/>
@ -1605,7 +1605,7 @@ The current public version of video.xml is maintained in the default branch
<type name="StdVideoH264PictureParameterSet"/>
</require>
</extension>
<extension name="vulkan_video_codec_h264std_decode" comment="protect with VULKAN_VIDEO_CODEC_H264STD_DECODE_H_" supported="vulkan">
<extension name="vulkan_video_codec_h264std_decode" number="3" comment="protect with VULKAN_VIDEO_CODEC_H264STD_DECODE_H_" supported="vulkan">
<require>
<type name="vk_video/vulkan_video_codec_h264std.h"/>
@ -1622,7 +1622,7 @@ The current public version of video.xml is maintained in the default branch
<type name="StdVideoDecodeH264ReferenceInfo"/>
</require>
</extension>
<extension name="vulkan_video_codec_h264std_encode" comment="protect with VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_" supported="vulkan">
<extension name="vulkan_video_codec_h264std_encode" number="4" comment="protect with VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_" supported="vulkan">
<require>
<type name="vk_video/vulkan_video_codec_h264std.h"/>
@ -1644,7 +1644,7 @@ The current public version of video.xml is maintained in the default branch
<type name="StdVideoEncodeH264SliceHeader"/>
</require>
</extension>
<extension name="vulkan_video_codec_h265std" comment="protect with VULKAN_VIDEO_CODEC_H265STD_H_" supported="vulkan">
<extension name="vulkan_video_codec_h265std" number="5" comment="protect with VULKAN_VIDEO_CODEC_H265STD_H_" supported="vulkan">
<require>
<type name="vk_video/vulkan_video_codecs_common.h"/>
@ -1699,7 +1699,7 @@ The current public version of video.xml is maintained in the default branch
<type name="StdVideoH265PictureParameterSet"/>
</require>
</extension>
<extension name="vulkan_video_codec_h265std_decode" comment="protect with VULKAN_VIDEO_CODEC_H265STD_DECODE_H_" supported="vulkan">
<extension name="vulkan_video_codec_h265std_decode" number="6" comment="protect with VULKAN_VIDEO_CODEC_H265STD_DECODE_H_" supported="vulkan">
<require>
<type name="vk_video/vulkan_video_codec_h265std.h"/>
@ -1715,7 +1715,7 @@ The current public version of video.xml is maintained in the default branch
<type name="StdVideoDecodeH265ReferenceInfo"/>
</require>
</extension>
<extension name="vulkan_video_codec_h265std_encode" comment="protect with VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_" supported="vulkan">
<extension name="vulkan_video_codec_h265std_encode" number="7" comment="protect with VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_" supported="vulkan">
<require>
<type name="vk_video/vulkan_video_codec_h265std.h"/>
@ -1736,7 +1736,7 @@ The current public version of video.xml is maintained in the default branch
<type name="StdVideoEncodeH265ReferenceInfo"/>
</require>
</extension>
<extension name="vulkan_video_codec_av1std" comment="protect with VULKAN_VIDEO_CODEC_AV1STD_H_" supported="vulkan">
<extension name="vulkan_video_codec_av1std" number="8" comment="protect with VULKAN_VIDEO_CODEC_AV1STD_H_" supported="vulkan">
<require>
<type name="vk_video/vulkan_video_codecs_common.h"/>
@ -1794,7 +1794,7 @@ The current public version of video.xml is maintained in the default branch
<type name="StdVideoAV1SequenceHeader"/>
</require>
</extension>
<extension name="vulkan_video_codec_av1std_decode" comment="protect with VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_" supported="vulkan">
<extension name="vulkan_video_codec_av1std_decode" number="9" comment="protect with VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_" supported="vulkan">
<require>
<type name="vk_video/vulkan_video_codec_av1std.h"/>
@ -1808,7 +1808,7 @@ The current public version of video.xml is maintained in the default branch
<type name="StdVideoDecodeAV1ReferenceInfo"/>
</require>
</extension>
<extension name="vulkan_video_codec_av1std_encode" comment="protect with VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_" supported="vulkan">
<extension name="vulkan_video_codec_av1std_encode" number="10" comment="protect with VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_" supported="vulkan">
<require>
<type name="vk_video/vulkan_video_codec_av1std.h"/>

115
registry/vk.xml
View file

@ -179,7 +179,7 @@ branch of the member gitlab server.
#define <name>VKSC_API_VERSION_1_0</name> <type>VK_MAKE_API_VERSION</type>(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0</type>
<type api="vulkan" category="define">// Version of this file
#define <name>VK_HEADER_VERSION</name> 312</type>
#define <name>VK_HEADER_VERSION</name> 313</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
@ -1505,7 +1505,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkDescriptorSetAllocateInfo">
<member values="VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkDescriptorPool</type> <name>descriptorPool</name></member>
<member externsync="true"><type>VkDescriptorPool</type> <name>descriptorPool</name></member>
<member><type>uint32_t</type> <name>descriptorSetCount</name></member>
<member len="descriptorSetCount">const <type>VkDescriptorSetLayout</type>* <name>pSetLayouts</name></member>
</type>
@ -1774,7 +1774,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkReleaseCapturedPipelineDataInfoKHR">
<member values="VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkPipeline</type> <name>pipeline</name></member>
<member externsync="true"><type>VkPipeline</type> <name>pipeline</name></member>
</type>
<type category="struct" name="VkPipelineBinaryDataInfoKHR">
<member values="VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
@ -1823,7 +1823,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<type category="struct" name="VkCommandBufferAllocateInfo">
<member values="VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkCommandPool</type> <name>commandPool</name></member>
<member externsync="true"><type>VkCommandPool</type> <name>commandPool</name></member>
<member><type>VkCommandBufferLevel</type> <name>level</name></member>
<member><type>uint32_t</type> <name>commandBufferCount</name></member>
</type>
@ -2319,7 +2319,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member optional="true"><type>VkSwapchainCreateFlagsKHR</type> <name>flags</name></member>
<member><type>VkSurfaceKHR</type> <name>surface</name><comment>The swapchain's target surface</comment></member>
<member externsync="true"><type>VkSurfaceKHR</type> <name>surface</name><comment>The swapchain's target surface</comment></member>
<member><type>uint32_t</type> <name>minImageCount</name><comment>Minimum number of presentation images the application needs</comment></member>
<member><type>VkFormat</type> <name>imageFormat</name><comment>Format of the presentation images</comment></member>
<member><type>VkColorSpaceKHR</type> <name>imageColorSpace</name><comment>Colorspace of the presentation images</comment></member>
@ -2333,16 +2333,16 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkCompositeAlphaFlagBitsKHR</type> <name>compositeAlpha</name><comment>The alpha blending mode used when compositing this surface with other surfaces in the window system</comment></member>
<member><type>VkPresentModeKHR</type> <name>presentMode</name><comment>Which presentation mode to use for presents on this swap chain</comment></member>
<member><type>VkBool32</type> <name>clipped</name><comment>Specifies whether presentable images may be affected by window clip regions</comment></member>
<member api="vulkan" optional="true"><type>VkSwapchainKHR</type> <name>oldSwapchain</name><comment>Existing swap chain to replace, if any</comment></member>
<member api="vulkan" optional="true" externsync="true"><type>VkSwapchainKHR</type> <name>oldSwapchain</name><comment>Existing swap chain to replace, if any</comment></member>
<member api="vulkansc" noautovalidity="true" optional="true"><type>VkSwapchainKHR</type> <name>oldSwapchain</name><comment>Existing swap chain to replace, if any</comment></member>
</type>
<type category="struct" name="VkPresentInfoKHR">
<member values="VK_STRUCTURE_TYPE_PRESENT_INFO_KHR"><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>waitSemaphoreCount</name><comment>Number of semaphores to wait for before presenting</comment></member>
<member len="waitSemaphoreCount">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name><comment>Semaphores to wait for before presenting</comment></member>
<member len="waitSemaphoreCount" externsync="true">const <type>VkSemaphore</type>* <name>pWaitSemaphores</name><comment>Semaphores to wait for before presenting</comment></member>
<member><type>uint32_t</type> <name>swapchainCount</name><comment>Number of swapchains to present in this call</comment></member>
<member len="swapchainCount">const <type>VkSwapchainKHR</type>* <name>pSwapchains</name><comment>Swapchains to present an image from</comment></member>
<member len="swapchainCount" externsync="true">const <type>VkSwapchainKHR</type>* <name>pSwapchains</name><comment>Swapchains to present an image from</comment></member>
<member len="swapchainCount">const <type>uint32_t</type>* <name>pImageIndices</name><comment>Indices of which presentable images to present</comment></member>
<member optional="true" len="swapchainCount"><type>VkResult</type>* <name>pResults</name><comment>Optional (i.e. if non-NULL) VkResult for each swapchain</comment></member>
</type>
@ -2397,14 +2397,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkDebugReportObjectTypeEXT</type> <name>objectType</name><comment>The type of the object</comment></member>
<member objecttype="objectType"><type>uint64_t</type> <name>object</name><comment>The handle of the object, cast to uint64_t</comment></member>
<member objecttype="objectType" externsync="true"><type>uint64_t</type> <name>object</name><comment>The handle of the object, cast to uint64_t</comment></member>
<member len="null-terminated">const <type>char</type>* <name>pObjectName</name><comment>Name to apply to the object</comment></member>
</type>
<type category="struct" name="VkDebugMarkerObjectTagInfoEXT">
<member values="VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkDebugReportObjectTypeEXT</type> <name>objectType</name><comment>The type of the object</comment></member>
<member objecttype="objectType"><type>uint64_t</type> <name>object</name><comment>The handle of the object, cast to uint64_t</comment></member>
<member objecttype="objectType" externsync="true"><type>uint64_t</type> <name>object</name><comment>The handle of the object, cast to uint64_t</comment></member>
<member><type>uint64_t</type> <name>tagName</name><comment>The name of the tag to set on the object</comment></member>
<member><type>size_t</type> <name>tagSize</name><comment>The length in bytes of the tag data</comment></member>
<member len="tagSize">const <type>void</type>* <name>pTag</name><comment>Tag data to attach to the object</comment></member>
@ -4196,14 +4196,14 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member values="VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkObjectType</type> <name>objectType</name></member>
<member objecttype="objectType"><type>uint64_t</type> <name>objectHandle</name></member>
<member objecttype="objectType"><type>uint64_t</type> <name>objectHandle</name></member>
<member optional="true" len="null-terminated">const <type>char</type>* <name>pObjectName</name></member>
</type>
<type category="struct" name="VkDebugUtilsObjectTagInfoEXT">
<member values="VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkObjectType</type> <name>objectType</name></member>
<member objecttype="objectType"><type>uint64_t</type> <name>objectHandle</name></member>
<member objecttype="objectType" externsync="true"><type>uint64_t</type> <name>objectHandle</name></member>
<member><type>uint64_t</type> <name>tagName</name></member>
<member><type>size_t</type> <name>tagSize</name></member>
<member len="tagSize">const <type>void</type>* <name>pTag</name></member>
@ -9185,6 +9185,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member><type>VkExtent2D</type> <name>apronSize</name></member>
<member><type>VkOffset2D</type> <name>origin</name></member>
</type>
<type category="struct" name="VkTileMemoryBindInfoQCOM" structextends="VkCommandBufferInheritanceInfo">
<member values="VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkDeviceMemory</type> <name>memory</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceAmigoProfilingFeaturesSEC" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
@ -9707,6 +9712,28 @@ typedef void* <name>MTLSharedEvent_id</name>;
<member optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkResult</type>* <name>pResult</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceTileMemoryHeapFeaturesQCOM" structextends="VkPhysicalDeviceFeatures2,VkDeviceCreateInfo">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<member noautovalidity="true" optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>tileMemoryHeap</name></member>
</type>
<type category="struct" name="VkPhysicalDeviceTileMemoryHeapPropertiesQCOM" structextends="VkPhysicalDeviceProperties2">
<member values="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<member noautovalidity="true" optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkBool32</type> <name>queueSubmitBoundary</name></member>
<member><type>VkBool32</type> <name>tileBufferTransfers</name></member>
</type>
<type category="struct" name="VkTileMemorySizeInfoQCOM" structextends="VkRenderPassCreateInfo,VkRenderPassCreateInfo2,VkRenderingInfo">
<member values="VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<member noautovalidity="true" optional="true">const <type>void</type>* <name>pNext</name></member>
<member><type>VkDeviceSize</type> <name>size</name></member>
</type>
<type category="struct" name="VkTileMemoryRequirementsQCOM" structextends="VkMemoryRequirements2">
<member values="VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM"><type>VkStructureType</type> <name>sType</name></member>
<member optional="true"><type>void</type>* <name>pNext</name></member>
<member><type>VkDeviceSize</type> <name>size</name></member>
<member><type>VkDeviceSize</type> <name>alignment</name></member>
</type>
<type category="struct" name="VkBindMemoryStatusKHR" alias="VkBindMemoryStatus"/>
<type category="struct" name="VkBindDescriptorSetsInfo">
<member values="VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO"><type>VkStructureType</type> <name>sType</name></member>
@ -12950,7 +12977,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command successcodes="VK_SUCCESS">
<proto><type>VkResult</type> <name>vkReleaseCapturedPipelineDataKHR</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param externsync="pInfo-&gt;pipeline">const <type>VkReleaseCapturedPipelineDataInfoKHR</type>* <name>pInfo</name></param>
<param>const <type>VkReleaseCapturedPipelineDataInfoKHR</type>* <name>pInfo</name></param>
<param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
</command>
<command api="vulkan" successcodes="VK_SUCCESS,VK_PIPELINE_COMPILE_REQUIRED_EXT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_INVALID_SHADER_NV">
@ -13065,7 +13092,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_FRAGMENTED_POOL,VK_ERROR_OUT_OF_POOL_MEMORY">
<proto><type>VkResult</type> <name>vkAllocateDescriptorSets</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param externsync="pAllocateInfo-&gt;descriptorPool">const <type>VkDescriptorSetAllocateInfo</type>* <name>pAllocateInfo</name></param>
<param>const <type>VkDescriptorSetAllocateInfo</type>* <name>pAllocateInfo</name></param>
<param len="pAllocateInfo-&gt;descriptorSetCount"><type>VkDescriptorSet</type>* <name>pDescriptorSets</name></param>
</command>
<command successcodes="VK_SUCCESS">
@ -13144,7 +13171,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
<proto><type>VkResult</type> <name>vkAllocateCommandBuffers</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param externsync="pAllocateInfo-&gt;commandPool">const <type>VkCommandBufferAllocateInfo</type>* <name>pAllocateInfo</name></param>
<param>const <type>VkCommandBufferAllocateInfo</type>* <name>pAllocateInfo</name></param>
<param len="pAllocateInfo-&gt;commandBufferCount"><type>VkCommandBuffer</type>* <name>pCommandBuffers</name></param>
</command>
<command>
@ -13648,8 +13675,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<proto><type>VkResult</type> <name>vkCreateSharedSwapchainsKHR</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param><type>uint32_t</type> <name>swapchainCount</name></param>
<param api="vulkan" len="swapchainCount" externsync="pCreateInfos[].surface,pCreateInfos[].oldSwapchain">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfos</name></param>
<param api="vulkansc" len="swapchainCount" externsync="pCreateInfos[].surface">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfos</name></param>
<param api="vulkan" len="swapchainCount">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfos</name></param>
<param api="vulkansc" len="swapchainCount">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfos</name></param>
<param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
<param len="swapchainCount"><type>VkSwapchainKHR</type>* <name>pSwapchains</name></param>
</command>
@ -13689,8 +13716,8 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,VK_ERROR_INITIALIZATION_FAILED,VK_ERROR_COMPRESSION_EXHAUSTED_EXT">
<proto><type>VkResult</type> <name>vkCreateSwapchainKHR</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param api="vulkan" externsync="pCreateInfo-&gt;surface,pCreateInfo-&gt;oldSwapchain">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfo</name></param>
<param api="vulkansc" externsync="pCreateInfo-&gt;surface">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfo</name></param>
<param api="vulkan">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfo</name></param>
<param api="vulkansc">const <type>VkSwapchainCreateInfoKHR</type>* <name>pCreateInfo</name></param>
<param optional="true">const <type>VkAllocationCallbacks</type>* <name>pAllocator</name></param>
<param><type>VkSwapchainKHR</type>* <name>pSwapchain</name></param>
</command>
@ -13719,7 +13746,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command successcodes="VK_SUCCESS,VK_SUBOPTIMAL_KHR" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST,VK_ERROR_OUT_OF_DATE_KHR,VK_ERROR_SURFACE_LOST_KHR,VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT">
<proto><type>VkResult</type> <name>vkQueuePresentKHR</name></proto>
<param externsync="true"><type>VkQueue</type> <name>queue</name></param>
<param externsync="pPresentInfo-&gt;pWaitSemaphores[],pPresentInfo-&gt;pSwapchains[]">const <type>VkPresentInfoKHR</type>* <name>pPresentInfo</name></param>
<param>const <type>VkPresentInfoKHR</type>* <name>pPresentInfo</name></param>
</command>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_NATIVE_WINDOW_IN_USE_KHR">
<proto><type>VkResult</type> <name>vkCreateViSurfaceNN</name></proto>
@ -13848,12 +13875,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
<proto><type>VkResult</type> <name>vkDebugMarkerSetObjectNameEXT</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param externsync="pNameInfo-&gt;object">const <type>VkDebugMarkerObjectNameInfoEXT</type>* <name>pNameInfo</name></param>
<param>const <type>VkDebugMarkerObjectNameInfoEXT</type>* <name>pNameInfo</name></param>
</command>
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
<proto><type>VkResult</type> <name>vkDebugMarkerSetObjectTagEXT</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param externsync="pTagInfo-&gt;object">const <type>VkDebugMarkerObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
<param>const <type>VkDebugMarkerObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
</command>
<command queues="graphics,compute" renderpass="both" cmdbufferlevel="primary,secondary" tasks="action">
<proto><type>void</type> <name>vkCmdDebugMarkerBeginEXT</name></proto>
@ -14694,7 +14721,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<command successcodes="VK_SUCCESS" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY">
<proto><type>VkResult</type> <name>vkSetDebugUtilsObjectTagEXT</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
<param externsync="pTagInfo-&gt;objectHandle">const <type>VkDebugUtilsObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
<param>const <type>VkDebugUtilsObjectTagInfoEXT</type>* <name>pTagInfo</name></param>
</command>
<command>
<proto><type>void</type> <name>vkQueueBeginDebugUtilsLabelEXT</name></proto>
@ -16492,6 +16519,11 @@ typedef void* <name>MTLSharedEvent_id</name>;
<param><type>VkDevice</type> <name>device</name></param>
<param><type>VkExportMetalObjectsInfoEXT</type>* <name>pMetalObjectsInfo</name></param>
</command>
<command queues="graphics,compute" renderpass="outside" cmdbufferlevel="primary,secondary" tasks="state">
<proto><type>void</type> <name>vkCmdBindTileMemoryQCOM</name></proto>
<param externsync="true"><type>VkCommandBuffer</type> <name>commandBuffer</name></param>
<param optional="true">const <type>VkTileMemoryBindInfoQCOM</type>* <name>pTileMemoryBindInfo</name></param>
</command>
<command successcodes="VK_SUCCESS,VK_INCOMPLETE">
<proto><type>VkResult</type> <name>vkGetFramebufferTilePropertiesQCOM</name></proto>
<param><type>VkDevice</type> <name>device</name></param>
@ -24552,7 +24584,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="micromap" struct="VkPhysicalDeviceOpacityMicromapFeaturesEXT"/>
</require>
</extension>
<extension name="VK_NV_displacement_micromap" number="398" type="device" depends="VK_EXT_opacity_micromap" author="NV" contact="Christoph Kubisch @pixeljetstream, Eric Werness @ewerness-nv" supported="vulkan" provisional="true" platform="provisional">
<extension name="VK_NV_displacement_micromap" number="398" type="device" depends="VK_EXT_opacity_micromap" author="NV" contact="Christoph Kubisch @pixeljetstream, Eric Werness @ewerness-nv" supported="vulkan" provisional="true" platform="provisional" deprecatedby="VK_NV_cluster_acceleration_structure">
<require>
<enum value="2" name="VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION"/>
<enum value="&quot;VK_NV_displacement_micromap&quot;" name="VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME"/>
@ -26539,14 +26571,28 @@ typedef void* <name>MTLSharedEvent_id</name>;
<feature name="descriptorPoolOverallocation" struct="VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV"/>
</require>
</extension>
<extension name="VK_QCOM_extension_548" number="548" type="device" author="QCOM" contact="Patrick Boyle @pboyleQCOM" supported="disabled">
<extension name="VK_QCOM_tile_memory_heap" number="548" type="device" author="QCOM" depends="(VK_KHR_get_memory_requirements2+VK_KHR_get_physical_device_properties2),VK_VERSION_1_1" contact="Patrick Boyle @pboyleQCOM" supported="vulkan">
<require>
<enum value="0" name="VK_QCOM_EXTENSION_548_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_extension_548&quot;" name="VK_QCOM_EXTENSION_548_EXTENSION_NAME"/>
<enum bitpos="3" extends="VkMemoryHeapFlagBits" name="VK_MEMORY_HEAP_RESERVED_3_QCOM"/>
<enum bitpos="27" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_RESERVED_27_BIT_QCOM"/>
<enum bitpos="27" extends="VkBufferUsageFlagBits2" name="VK_BUFFER_USAGE_2_RESERVED_27_BIT_QCOM"/>
<enum bitpos="27" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_RESERVED_27_QCOM"/>
<enum value="1" name="VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION"/>
<enum value="&quot;VK_QCOM_tile_memory_heap&quot;" name="VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME"/>
<enum bitpos="3" extends="VkMemoryHeapFlagBits" name="VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM"/>
<enum bitpos="27" extends="VkBufferUsageFlagBits" name="VK_BUFFER_USAGE_TILE_MEMORY_QCOM"/>
<enum bitpos="27" extends="VkBufferUsageFlagBits2" name="VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM"/>
<enum bitpos="27" extends="VkImageUsageFlagBits" name="VK_IMAGE_USAGE_TILE_MEMORY_QCOM"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM"/>
<enum offset="2" extends="VkStructureType" name="VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM"/>
<enum offset="3" extends="VkStructureType" name="VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM"/>
<type name="VkPhysicalDeviceTileMemoryHeapFeaturesQCOM"/>
<type name="VkPhysicalDeviceTileMemoryHeapPropertiesQCOM"/>
<type name="VkTileMemoryRequirementsQCOM"/>
<type name="VkTileMemoryBindInfoQCOM"/>
<command name="vkCmdBindTileMemoryQCOM"/>
<feature name="tileMemoryHeap" struct="VkPhysicalDeviceTileMemoryHeapFeaturesQCOM"/>
</require>
<require depends="VK_QCOM_tile_properties">
<enum offset="4" extends="VkStructureType" name="VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM"/>
<type name="VkTileMemorySizeInfoQCOM"/>
</require>
</extension>
<extension name="VK_NV_extension_549" number="549" author="NV" contact="Piers Daniell @pdaniell-nv" supported="disabled">
@ -27326,6 +27372,7 @@ typedef void* <name>MTLSharedEvent_id</name>;
<require>
<enum value="0" name="VK_EXT_EXTENSION_621_SPEC_VERSION"/>
<enum value="&quot;VK_EXT_extension_621&quot;" name="VK_EXT_EXTENSION_621_EXTENSION_NAME"/>
<enum bitpos="3" extends="VkMemoryAllocateFlagBits" name="VK_MEMORY_ALLOCATE_EXTENSION_621_BIT_EXT"/>
</require>
</extension>
<extension name="VK_EXT_extension_622" number="622" author="EXT" contact="Lina Versace @linyaa" supported="disabled">
@ -27367,6 +27414,12 @@ typedef void* <name>MTLSharedEvent_id</name>;
<enum value="&quot;VK_EXT_extension_626&quot;" name="VK_EXT_EXTENSION_626_EXTENSION_NAME"/>
</require>
</extension>
<extension name="VK_NV_extension_627" number="627" author="NV" contact="Jeff Juliano @jjuliano" supported="disabled">
<require>
<enum value="0" name="VK_NV_EXTENSION_627_SPEC_VERSION"/>
<enum value="&quot;VK_NV_extension_627&quot;" name="VK_NV_EXTENSION_627_EXTENSION_NAME"/>
</require>
</extension>
</extensions>
<formats>
<format name="VK_FORMAT_R4G4_UNORM_PACK8" class="8-bit" blockSize="1" texelsPerBlock="1" packed="8">