diff --git a/third_party/vk_video/vulkan_video_codec_vp9std.h b/third_party/vk_video/vulkan_video_codec_vp9std.h
new file mode 100644
index 0000000..61743cd
--- /dev/null
+++ b/third_party/vk_video/vulkan_video_codec_vp9std.h
@@ -0,0 +1,151 @@
+#ifndef VULKAN_VIDEO_CODEC_VP9STD_H_
+#define VULKAN_VIDEO_CODEC_VP9STD_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
+
+
+
+// vulkan_video_codec_vp9std is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_vp9std 1
+#include "vulkan_video_codecs_common.h"
+#define STD_VIDEO_VP9_NUM_REF_FRAMES 8
+#define STD_VIDEO_VP9_REFS_PER_FRAME 3
+#define STD_VIDEO_VP9_MAX_REF_FRAMES 4
+#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2
+#define STD_VIDEO_VP9_MAX_SEGMENTS 8
+#define STD_VIDEO_VP9_SEG_LVL_MAX 4
+#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7
+#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3
+
+typedef enum StdVideoVP9Profile {
+ STD_VIDEO_VP9_PROFILE_0 = 0,
+ STD_VIDEO_VP9_PROFILE_1 = 1,
+ STD_VIDEO_VP9_PROFILE_2 = 2,
+ STD_VIDEO_VP9_PROFILE_3 = 3,
+ STD_VIDEO_VP9_PROFILE_INVALID = 0x7FFFFFFF,
+ STD_VIDEO_VP9_PROFILE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9Profile;
+
+typedef enum StdVideoVP9Level {
+ STD_VIDEO_VP9_LEVEL_1_0 = 0,
+ STD_VIDEO_VP9_LEVEL_1_1 = 1,
+ STD_VIDEO_VP9_LEVEL_2_0 = 2,
+ STD_VIDEO_VP9_LEVEL_2_1 = 3,
+ STD_VIDEO_VP9_LEVEL_3_0 = 4,
+ STD_VIDEO_VP9_LEVEL_3_1 = 5,
+ STD_VIDEO_VP9_LEVEL_4_0 = 6,
+ STD_VIDEO_VP9_LEVEL_4_1 = 7,
+ STD_VIDEO_VP9_LEVEL_5_0 = 8,
+ STD_VIDEO_VP9_LEVEL_5_1 = 9,
+ STD_VIDEO_VP9_LEVEL_5_2 = 10,
+ STD_VIDEO_VP9_LEVEL_6_0 = 11,
+ STD_VIDEO_VP9_LEVEL_6_1 = 12,
+ STD_VIDEO_VP9_LEVEL_6_2 = 13,
+ STD_VIDEO_VP9_LEVEL_INVALID = 0x7FFFFFFF,
+ STD_VIDEO_VP9_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9Level;
+
+typedef enum StdVideoVP9FrameType {
+ STD_VIDEO_VP9_FRAME_TYPE_KEY = 0,
+ STD_VIDEO_VP9_FRAME_TYPE_NON_KEY = 1,
+ STD_VIDEO_VP9_FRAME_TYPE_INVALID = 0x7FFFFFFF,
+ STD_VIDEO_VP9_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9FrameType;
+
+typedef enum StdVideoVP9ReferenceName {
+ STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME = 0,
+ STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME = 1,
+ STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME = 2,
+ STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME = 3,
+ STD_VIDEO_VP9_REFERENCE_NAME_INVALID = 0x7FFFFFFF,
+ STD_VIDEO_VP9_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9ReferenceName;
+
+typedef enum StdVideoVP9InterpolationFilter {
+ STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP = 0,
+ STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1,
+ STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2,
+ STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR = 3,
+ STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE = 4,
+ STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF,
+ STD_VIDEO_VP9_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9InterpolationFilter;
+
+typedef enum StdVideoVP9ColorSpace {
+ STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN = 0,
+ STD_VIDEO_VP9_COLOR_SPACE_BT_601 = 1,
+ STD_VIDEO_VP9_COLOR_SPACE_BT_709 = 2,
+ STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170 = 3,
+ STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240 = 4,
+ STD_VIDEO_VP9_COLOR_SPACE_BT_2020 = 5,
+ STD_VIDEO_VP9_COLOR_SPACE_RESERVED = 6,
+ STD_VIDEO_VP9_COLOR_SPACE_RGB = 7,
+ STD_VIDEO_VP9_COLOR_SPACE_INVALID = 0x7FFFFFFF,
+ STD_VIDEO_VP9_COLOR_SPACE_MAX_ENUM = 0x7FFFFFFF
+} StdVideoVP9ColorSpace;
+typedef struct StdVideoVP9ColorConfigFlags {
+ uint32_t color_range : 1;
+ uint32_t reserved : 31;
+} StdVideoVP9ColorConfigFlags;
+
+typedef struct StdVideoVP9ColorConfig {
+ StdVideoVP9ColorConfigFlags flags;
+ uint8_t BitDepth;
+ uint8_t subsampling_x;
+ uint8_t subsampling_y;
+ uint8_t reserved1;
+ StdVideoVP9ColorSpace color_space;
+} StdVideoVP9ColorConfig;
+
+typedef struct StdVideoVP9LoopFilterFlags {
+ uint32_t loop_filter_delta_enabled : 1;
+ uint32_t loop_filter_delta_update : 1;
+ uint32_t reserved : 30;
+} StdVideoVP9LoopFilterFlags;
+
+typedef struct StdVideoVP9LoopFilter {
+ StdVideoVP9LoopFilterFlags flags;
+ uint8_t loop_filter_level;
+ uint8_t loop_filter_sharpness;
+ uint8_t update_ref_delta;
+ int8_t loop_filter_ref_deltas[STD_VIDEO_VP9_MAX_REF_FRAMES];
+ uint8_t update_mode_delta;
+ int8_t loop_filter_mode_deltas[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS];
+} StdVideoVP9LoopFilter;
+
+typedef struct StdVideoVP9SegmentationFlags {
+ 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;
+} StdVideoVP9SegmentationFlags;
+
+typedef struct StdVideoVP9Segmentation {
+ StdVideoVP9SegmentationFlags flags;
+ uint8_t segmentation_tree_probs[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS];
+ uint8_t segmentation_pred_prob[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB];
+ uint8_t FeatureEnabled[STD_VIDEO_VP9_MAX_SEGMENTS];
+ int16_t FeatureData[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX];
+} StdVideoVP9Segmentation;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vk_video/vulkan_video_codec_vp9std_decode.h b/third_party/vk_video/vulkan_video_codec_vp9std_decode.h
new file mode 100644
index 0000000..42b9bd3
--- /dev/null
+++ b/third_party/vk_video/vulkan_video_codec_vp9std_decode.h
@@ -0,0 +1,68 @@
+#ifndef VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_
+#define VULKAN_VIDEO_CODEC_VP9STD_DECODE_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
+
+
+
+// vulkan_video_codec_vp9std_decode is a preprocessor guard. Do not pass it to API calls.
+#define vulkan_video_codec_vp9std_decode 1
+#include "vulkan_video_codec_vp9std.h"
+
+#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0)
+
+#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0
+#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_vp9_decode"
+typedef struct StdVideoDecodeVP9PictureInfoFlags {
+ 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;
+} StdVideoDecodeVP9PictureInfoFlags;
+
+typedef struct StdVideoDecodeVP9PictureInfo {
+ StdVideoDecodeVP9PictureInfoFlags flags;
+ StdVideoVP9Profile profile;
+ StdVideoVP9FrameType frame_type;
+ uint8_t frame_context_idx;
+ uint8_t reset_frame_context;
+ uint8_t refresh_frame_flags;
+ uint8_t ref_frame_sign_bias_mask;
+ StdVideoVP9InterpolationFilter interpolation_filter;
+ 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;
+ uint16_t reserved1[3];
+ const StdVideoVP9ColorConfig* pColorConfig;
+ const StdVideoVP9LoopFilter* pLoopFilter;
+ const StdVideoVP9Segmentation* pSegmentation;
+} StdVideoDecodeVP9PictureInfo;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vma.h b/third_party/vma.h
index 6f71d5b..8df0364 100644
--- a/third_party/vma.h
+++ b/third_party/vma.h
@@ -25,7 +25,7 @@
/** \mainpage Vulkan Memory Allocator
-Version 3.2.1
+Version 3.3.0
Copyright (c) 2017-2025 Advanced Micro Devices, Inc. All rights reserved. \n
License: MIT \n
@@ -37,48 +37,48 @@ See also: [product page on GPUOpen](https://gpuopen.com/gaming-product/vulkan-me
General documentation chapters:
-- User guide
- - \subpage quick_start
- - [Project setup](@ref quick_start_project_setup)
- - [Initialization](@ref quick_start_initialization)
- - [Resource allocation](@ref quick_start_resource_allocation)
- - \subpage choosing_memory_type
- - [Usage](@ref choosing_memory_type_usage)
- - [Required and preferred flags](@ref choosing_memory_type_required_preferred_flags)
- - [Explicit memory types](@ref choosing_memory_type_explicit_memory_types)
- - [Custom memory pools](@ref choosing_memory_type_custom_memory_pools)
- - [Dedicated allocations](@ref choosing_memory_type_dedicated_allocations)
- - \subpage memory_mapping
- - [Copy functions](@ref memory_mapping_copy_functions)
- - [Mapping functions](@ref memory_mapping_mapping_functions)
- - [Persistently mapped memory](@ref memory_mapping_persistently_mapped_memory)
- - [Cache flush and invalidate](@ref memory_mapping_cache_control)
- - \subpage staying_within_budget
- - [Querying for budget](@ref staying_within_budget_querying_for_budget)
- - [Controlling memory usage](@ref staying_within_budget_controlling_memory_usage)
- - \subpage resource_aliasing
- - \subpage custom_memory_pools
- - [Choosing memory type index](@ref custom_memory_pools_MemTypeIndex)
- - [When not to use custom pools](@ref custom_memory_pools_when_not_use)
- - [Linear allocation algorithm](@ref linear_algorithm)
- - [Free-at-once](@ref linear_algorithm_free_at_once)
- - [Stack](@ref linear_algorithm_stack)
- - [Double stack](@ref linear_algorithm_double_stack)
- - [Ring buffer](@ref linear_algorithm_ring_buffer)
- - \subpage defragmentation
- - \subpage statistics
- - [Numeric statistics](@ref statistics_numeric_statistics)
- - [JSON dump](@ref statistics_json_dump)
- - \subpage allocation_annotation
- - [Allocation user data](@ref allocation_user_data)
- - [Allocation names](@ref allocation_names)
- - \subpage virtual_allocator
- - \subpage debugging_memory_usage
- - [Memory initialization](@ref debugging_memory_usage_initialization)
- - [Margins](@ref debugging_memory_usage_margins)
- - [Corruption detection](@ref debugging_memory_usage_corruption_detection)
- - [Leak detection features](@ref debugging_memory_usage_leak_detection)
- - \subpage other_api_interop
+- \subpage faq
+- \subpage quick_start
+ - [Project setup](@ref quick_start_project_setup)
+ - [Initialization](@ref quick_start_initialization)
+ - [Resource allocation](@ref quick_start_resource_allocation)
+- \subpage choosing_memory_type
+ - [Usage](@ref choosing_memory_type_usage)
+ - [Required and preferred flags](@ref choosing_memory_type_required_preferred_flags)
+ - [Explicit memory types](@ref choosing_memory_type_explicit_memory_types)
+ - [Custom memory pools](@ref choosing_memory_type_custom_memory_pools)
+ - [Dedicated allocations](@ref choosing_memory_type_dedicated_allocations)
+- \subpage memory_mapping
+ - [Copy functions](@ref memory_mapping_copy_functions)
+ - [Mapping functions](@ref memory_mapping_mapping_functions)
+ - [Persistently mapped memory](@ref memory_mapping_persistently_mapped_memory)
+ - [Cache flush and invalidate](@ref memory_mapping_cache_control)
+- \subpage staying_within_budget
+ - [Querying for budget](@ref staying_within_budget_querying_for_budget)
+ - [Controlling memory usage](@ref staying_within_budget_controlling_memory_usage)
+- \subpage resource_aliasing
+- \subpage custom_memory_pools
+ - [Choosing memory type index](@ref custom_memory_pools_MemTypeIndex)
+ - [When not to use custom pools](@ref custom_memory_pools_when_not_use)
+ - [Linear allocation algorithm](@ref linear_algorithm)
+ - [Free-at-once](@ref linear_algorithm_free_at_once)
+ - [Stack](@ref linear_algorithm_stack)
+ - [Double stack](@ref linear_algorithm_double_stack)
+ - [Ring buffer](@ref linear_algorithm_ring_buffer)
+- \subpage defragmentation
+- \subpage statistics
+ - [Numeric statistics](@ref statistics_numeric_statistics)
+ - [JSON dump](@ref statistics_json_dump)
+- \subpage allocation_annotation
+ - [Allocation user data](@ref allocation_user_data)
+ - [Allocation names](@ref allocation_names)
+- \subpage virtual_allocator
+- \subpage debugging_memory_usage
+ - [Memory initialization](@ref debugging_memory_usage_initialization)
+ - [Margins](@ref debugging_memory_usage_margins)
+ - [Corruption detection](@ref debugging_memory_usage_corruption_detection)
+ - [Leak detection features](@ref debugging_memory_usage_leak_detection)
+- \subpage other_api_interop
- \subpage usage_patterns
- [GPU-only resource](@ref usage_patterns_gpu_only)
- [Staging copy for upload](@ref usage_patterns_staging_copy_upload)
@@ -1669,6 +1669,62 @@ typedef struct VmaVirtualAllocationInfo
@{
*/
+#ifdef VOLK_HEADER_VERSION
+/** \brief Fully initializes `pDstVulkanFunctions` structure with Vulkan functions needed by VMA
+using [volk library](https://github.com/zeux/volk).
+
+This function is defined in VMA header only if "volk.h" was included before it.
+
+To use this function properly:
+
+-# Initialize volk and Vulkan:
+ -# Call `volkInitialize()`
+ -# Create `VkInstance` object
+ -# Call `volkLoadInstance()`
+ -# Create `VkDevice` object
+ -# Call `volkLoadDevice()`
+-# Fill in structure #VmaAllocatorCreateInfo, especially members:
+ - VmaAllocatorCreateInfo::device
+ - VmaAllocatorCreateInfo::vulkanApiVersion
+ - VmaAllocatorCreateInfo::flags - set appropriate flags for the Vulkan extensions you enabled
+-# Create an instance of the #VmaVulkanFunctions structure.
+-# Call vmaImportVulkanFunctionsFromVolk().
+ Parameter `pAllocatorCreateInfo` is read to find out which functions should be fetched for
+ appropriate Vulkan version and extensions.
+ Parameter `pDstVulkanFunctions` is filled with those function pointers, or null if not applicable.
+-# Attach the #VmaVulkanFunctions structure to VmaAllocatorCreateInfo::pVulkanFunctions.
+-# Call vmaCreateAllocator() to create the #VmaAllocator object.
+
+Example:
+
+\code
+VmaAllocatorCreateInfo allocatorCreateInfo = {};
+allocatorCreateInfo.physicalDevice = myPhysicalDevice;
+allocatorCreateInfo.device = myDevice;
+allocatorCreateInfo.instance = myInstance;
+allocatorCreateInfo.vulkanApiVersion = VK_API_VERSION_1_3;
+allocatorCreateInfo.flags = VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT |
+ VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT |
+ VMA_ALLOCATOR_CREATE_KHR_EXTERNAL_MEMORY_WIN32_BIT;
+
+VmaVulkanFunctions vulkanFunctions;
+VkResult res = vmaImportVulkanFunctionsFromVolk(&allocatorCreateInfo, &vulkanFunctions);
+// Check res...
+allocatorCreateInfo.pVulkanFunctions = &vulkanFunctions;
+
+VmaAllocator allocator;
+res = vmaCreateAllocator(&allocatorCreateInfo, &allocator);
+// Check res...
+\endcode
+
+Internally in this function, pointers to functions related to the entire Vulkan instance are fetched using global function definitions,
+while pointers to functions related to the Vulkan device are fetched using `volkLoadDeviceTable()` for given `pAllocatorCreateInfo->device`.
+ */
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaImportVulkanFunctionsFromVolk(
+ const VmaAllocatorCreateInfo* VMA_NOT_NULL pAllocatorCreateInfo,
+ VmaVulkanFunctions* VMA_NOT_NULL pDstVulkanFunctions);
+#endif
+
/// Creates #VmaAllocator object.
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
const VmaAllocatorCreateInfo* VMA_NOT_NULL pCreateInfo,
@@ -1999,7 +2055,7 @@ Passing `VK_NULL_HANDLE` as `allocation` is valid. Such function call is just sk
*/
VMA_CALL_PRE void VMA_CALL_POST vmaFreeMemory(
VmaAllocator VMA_NOT_NULL allocator,
- const VmaAllocation VMA_NULLABLE allocation);
+ VmaAllocation VMA_NULLABLE allocation);
/** \brief Frees memory and destroys multiple allocations.
@@ -3134,7 +3190,7 @@ static void vma_aligned_free(void* VMA_NULLABLE ptr)
{
VMA_CLASS_NO_COPY_NO_MOVE(VmaMutex)
public:
- VmaMutex() { }
+ VmaMutex() = default;
void Lock() { m_Mutex.lock(); }
void Unlock() { m_Mutex.unlock(); }
bool TryLock() { return m_Mutex.try_lock(); }
@@ -3276,17 +3332,28 @@ If providing your own implementation, you need to implement a subset of std::ato
Set this to 1 to make VMA never exceed VkPhysicalDeviceLimits::maxMemoryAllocationCount
and return error instead of leaving up to Vulkan implementation what to do in such cases.
*/
- #define VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT (0)
+ #define VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT (1)
+#endif
+
+#ifndef VMA_DEBUG_DONT_EXCEED_HEAP_SIZE_WITH_ALLOCATION_SIZE
+ /*
+ Set this to 1 to make VMA never exceed VkPhysicalDeviceMemoryProperties::memoryHeaps[i].size
+ with a single allocation size VkMemoryAllocateInfo::allocationSize
+ and return error instead of leaving up to Vulkan implementation what to do in such cases.
+ It protects agaist validation error VUID-vkAllocateMemory-pAllocateInfo-01713.
+ On the other hand, allowing exceeding this size may result in a successful allocation despite the validation error.
+ */
+ #define VMA_DEBUG_DONT_EXCEED_HEAP_SIZE_WITH_ALLOCATION_SIZE (1)
#endif
#ifndef VMA_SMALL_HEAP_MAX_SIZE
/// Maximum size of a memory heap in Vulkan to consider it "small".
- #define VMA_SMALL_HEAP_MAX_SIZE (1024ull * 1024 * 1024)
+ #define VMA_SMALL_HEAP_MAX_SIZE (1024ULL * 1024 * 1024)
#endif
#ifndef VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE
/// Default size of a block allocated as single VkDeviceMemory from a "large" heap.
- #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ull * 1024 * 1024)
+ #define VMA_DEFAULT_LARGE_HEAP_BLOCK_SIZE (256ULL * 1024 * 1024)
#endif
/*
@@ -3322,7 +3389,7 @@ static const uint32_t VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD_COPY = 0x000000
static const uint32_t VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_COPY = 0x00020000;
static const uint32_t VK_IMAGE_CREATE_DISJOINT_BIT_COPY = 0x00000200;
static const int32_t VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT_COPY = 1000158000;
-static const uint32_t VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000u;
+static const uint32_t VMA_ALLOCATION_INTERNAL_STRATEGY_MIN_OFFSET = 0x10000000U;
static const uint32_t VMA_ALLOCATION_TRY_COUNT = 32;
static const uint32_t VMA_VENDOR_ID_AMD = 4098;
@@ -3334,7 +3401,7 @@ static const uint32_t VMA_VENDOR_ID_AMD = 4098;
#if VMA_STATS_STRING_ENABLED
// Correspond to values of enum VmaSuballocationType.
-static const char* VMA_SUBALLOCATION_TYPE_NAMES[] =
+static const char* const VMA_SUBALLOCATION_TYPE_NAMES[] =
{
"FREE",
"UNKNOWN",
@@ -3345,7 +3412,7 @@ static const char* VMA_SUBALLOCATION_TYPE_NAMES[] =
};
#endif
-static VkAllocationCallbacks VmaEmptyAllocationCallbacks =
+static const VkAllocationCallbacks VmaEmptyAllocationCallbacks =
{ VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL, VMA_NULL };
@@ -3486,7 +3553,7 @@ static inline uint8_t VmaBitScanLSB(uint64_t mask)
return static_cast(pos);
return UINT8_MAX;
#elif VMA_CPP20
- if(mask)
+ if(mask != 0)
return static_cast(std::countr_zero(mask));
return UINT8_MAX;
#elif defined __GNUC__ || defined __clang__
@@ -3512,7 +3579,7 @@ static inline uint8_t VmaBitScanLSB(uint32_t mask)
return static_cast(pos);
return UINT8_MAX;
#elif VMA_CPP20
- if(mask)
+ if(mask != 0)
return static_cast(std::countr_zero(mask));
return UINT8_MAX;
#elif defined __GNUC__ || defined __clang__
@@ -3537,10 +3604,10 @@ static inline uint8_t VmaBitScanMSB(uint64_t mask)
if (_BitScanReverse64(&pos, mask))
return static_cast(pos);
#elif VMA_CPP20
- if(mask)
+ if(mask != 0)
return 63 - static_cast(std::countl_zero(mask));
#elif defined __GNUC__ || defined __clang__
- if (mask)
+ if (mask != 0)
return 63 - static_cast(__builtin_clzll(mask));
#else
uint8_t pos = 63;
@@ -3562,10 +3629,10 @@ static inline uint8_t VmaBitScanMSB(uint32_t mask)
if (_BitScanReverse(&pos, mask))
return static_cast(pos);
#elif VMA_CPP20
- if(mask)
+ if(mask != 0)
return 31 - static_cast(std::countl_zero(mask));
#elif defined __GNUC__ || defined __clang__
- if (mask)
+ if (mask != 0)
return 31 - static_cast(__builtin_clz(mask));
#else
uint8_t pos = 31;
@@ -3795,7 +3862,8 @@ new element with value (key) should be inserted.
template
static IterT VmaBinaryFindFirstNotLess(IterT beg, IterT end, const KeyT& key, const CmpLess& cmp)
{
- size_t down = 0, up = size_t(end - beg);
+ size_t down = 0;
+ size_t up = size_t(end - beg);
while (down < up)
{
const size_t mid = down + (up - down) / 2; // Overflow-safe midpoint calculation
@@ -3914,7 +3982,7 @@ VmaBufferImageUsage::VmaBufferImageUsage(const VkBufferCreateInfo &createInfo,
// of the VK_KHR_maintenance5 extension.
const VkBufferUsageFlags2CreateInfoKHR* const usageFlags2 =
VmaPnextChainFind(&createInfo, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR);
- if(usageFlags2)
+ if(usageFlags2 != VMA_NULL)
{
this->Value = usageFlags2->usage;
return;
@@ -3926,11 +3994,10 @@ VmaBufferImageUsage::VmaBufferImageUsage(const VkBufferCreateInfo &createInfo,
}
VmaBufferImageUsage::VmaBufferImageUsage(const VkImageCreateInfo &createInfo)
+ : Value((BaseType)createInfo.usage)
{
// Maybe in the future there will be VK_KHR_maintenanceN extension with structure
// VkImageUsageFlags2CreateInfoKHR, like the one for buffers...
-
- this->Value = (BaseType)createInfo.usage;
}
// This is the main algorithm that guides the selection of a memory type best for an allocation -
@@ -4283,7 +4350,7 @@ struct VmaMutexLock
{
VMA_CLASS_NO_COPY_NO_MOVE(VmaMutexLock)
public:
- VmaMutexLock(VMA_MUTEX& mutex, bool useMutex = true) :
+ explicit VmaMutexLock(VMA_MUTEX& mutex, bool useMutex = true) :
m_pMutex(useMutex ? &mutex : VMA_NULL)
{
if (m_pMutex) { m_pMutex->Lock(); }
@@ -4368,9 +4435,9 @@ struct VmaStlAllocator
const VkAllocationCallbacks* const m_pCallbacks;
typedef T value_type;
- VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) {}
+ explicit VmaStlAllocator(const VkAllocationCallbacks* pCallbacks) : m_pCallbacks(pCallbacks) {}
template
- VmaStlAllocator(const VmaStlAllocator& src) : m_pCallbacks(src.m_pCallbacks) {}
+ explicit VmaStlAllocator(const VmaStlAllocator& src) : m_pCallbacks(src.m_pCallbacks) {}
VmaStlAllocator(const VmaStlAllocator&) = default;
VmaStlAllocator& operator=(const VmaStlAllocator&) = delete;
@@ -4402,7 +4469,7 @@ public:
typedef T* iterator;
typedef const T* const_iterator;
- VmaVector(const AllocatorT& allocator);
+ explicit VmaVector(const AllocatorT& allocator);
VmaVector(size_t count, const AllocatorT& allocator);
// This version of the constructor is here for compatibility with pre-C++14 std::vector.
// value is unused.
@@ -4618,10 +4685,10 @@ public:
typedef T value_type;
typedef T* iterator;
- VmaSmallVector(const AllocatorT& allocator);
+ explicit VmaSmallVector(const AllocatorT& allocator);
VmaSmallVector(size_t count, const AllocatorT& allocator);
template
- VmaSmallVector(const VmaSmallVector&) = delete;
+ explicit VmaSmallVector(const VmaSmallVector&) = delete;
template
VmaSmallVector& operator=(const VmaSmallVector&) = delete;
~VmaSmallVector() = default;
@@ -4848,7 +4915,7 @@ void VmaPoolAllocator::Free(T* ptr)
ItemBlock& block = m_ItemBlocks[i];
// Casting to union.
- Item* pItemPtr;
+ Item* pItemPtr = VMA_NULL;
memcpy(&pItemPtr, &ptr, sizeof(pItemPtr));
// Check if pItemPtr is in address range of this block.
@@ -4905,7 +4972,7 @@ class VmaRawList
public:
typedef VmaListItem ItemType;
- VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
+ explicit VmaRawList(const VkAllocationCallbacks* pAllocationCallbacks);
// Intentionally not calling Clear, because that would be unnecessary
// computations to return all items to m_ItemAllocator as free.
~VmaRawList() = default;
@@ -5045,7 +5112,7 @@ void VmaRawList::PopBack()
template
void VmaRawList::Clear()
{
- if (IsEmpty() == false)
+ if (!IsEmpty())
{
ItemType* pItem = m_pBack;
while (pItem != VMA_NULL)
@@ -5112,8 +5179,7 @@ VmaListItem* VmaRawList::InsertBefore(ItemType* pItem)
++m_Count;
return newItem;
}
- else
- return PushBack();
+ return PushBack();
}
template
@@ -5138,8 +5204,7 @@ VmaListItem* VmaRawList::InsertAfter(ItemType* pItem)
++m_Count;
return newItem;
}
- else
- return PushFront();
+ return PushFront();
}
template
@@ -5176,7 +5241,7 @@ public:
friend class VmaList;
public:
iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
- iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+ explicit iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }
@@ -5184,8 +5249,8 @@ public:
bool operator==(const iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
bool operator!=(const iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }
- iterator operator++(int) { iterator result = *this; ++*this; return result; }
- iterator operator--(int) { iterator result = *this; --*this; return result; }
+ const iterator operator++(int) { iterator result = *this; ++*this; return result; }
+ const iterator operator--(int) { iterator result = *this; --*this; return result; }
iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pNext; return *this; }
iterator& operator--();
@@ -5202,7 +5267,7 @@ public:
friend class VmaList;
public:
reverse_iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
- reverse_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+ explicit reverse_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
T& operator*() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return m_pItem->Value; }
T* operator->() const { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); return &m_pItem->Value; }
@@ -5210,8 +5275,8 @@ public:
bool operator==(const reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
bool operator!=(const reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }
- reverse_iterator operator++(int) { reverse_iterator result = *this; ++* this; return result; }
- reverse_iterator operator--(int) { reverse_iterator result = *this; --* this; return result; }
+ const reverse_iterator operator++(int) { reverse_iterator result = *this; ++* this; return result; }
+ const reverse_iterator operator--(int) { reverse_iterator result = *this; --* this; return result; }
reverse_iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pPrev; return *this; }
reverse_iterator& operator--();
@@ -5227,8 +5292,8 @@ public:
friend class VmaList;
public:
const_iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
- const_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
- const_iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+ explicit const_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+ explicit const_iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
iterator drop_const() { return { const_cast*>(m_pList), const_cast*>(m_pItem) }; }
@@ -5238,8 +5303,8 @@ public:
bool operator==(const const_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
bool operator!=(const const_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }
- const_iterator operator++(int) { const_iterator result = *this; ++* this; return result; }
- const_iterator operator--(int) { const_iterator result = *this; --* this; return result; }
+ const const_iterator operator++(int) { const_iterator result = *this; ++* this; return result; }
+ const const_iterator operator--(int) { const_iterator result = *this; --* this; return result; }
const_iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pNext; return *this; }
const_iterator& operator--();
@@ -5255,8 +5320,8 @@ public:
friend class VmaList;
public:
const_reverse_iterator() : m_pList(VMA_NULL), m_pItem(VMA_NULL) {}
- const_reverse_iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
- const_reverse_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+ explicit const_reverse_iterator(const reverse_iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
+ explicit const_reverse_iterator(const iterator& src) : m_pList(src.m_pList), m_pItem(src.m_pItem) {}
reverse_iterator drop_const() { return { const_cast*>(m_pList), const_cast*>(m_pItem) }; }
@@ -5266,8 +5331,8 @@ public:
bool operator==(const const_reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem == rhs.m_pItem; }
bool operator!=(const const_reverse_iterator& rhs) const { VMA_HEAVY_ASSERT(m_pList == rhs.m_pList); return m_pItem != rhs.m_pItem; }
- const_reverse_iterator operator++(int) { const_reverse_iterator result = *this; ++* this; return result; }
- const_reverse_iterator operator--(int) { const_reverse_iterator result = *this; --* this; return result; }
+ const const_reverse_iterator operator++(int) { const_reverse_iterator result = *this; ++* this; return result; }
+ const const_reverse_iterator operator--(int) { const_reverse_iterator result = *this; --* this; return result; }
const_reverse_iterator& operator++() { VMA_HEAVY_ASSERT(m_pItem != VMA_NULL); m_pItem = m_pItem->pPrev; return *this; }
const_reverse_iterator& operator--();
@@ -5279,7 +5344,7 @@ public:
const_reverse_iterator(const VmaRawList* pList, const VmaListItem* pItem) : m_pList(pList), m_pItem(pItem) {}
};
- VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) {}
+ explicit VmaList(const AllocatorT& allocator) : m_RawList(allocator.m_pCallbacks) {}
bool empty() const { return m_RawList.IsEmpty(); }
size_t size() const { return m_RawList.GetCount(); }
@@ -5397,9 +5462,9 @@ public:
// Movable, not copyable.
VmaIntrusiveLinkedList() = default;
- VmaIntrusiveLinkedList(VmaIntrusiveLinkedList && src);
+ VmaIntrusiveLinkedList(VmaIntrusiveLinkedList && src) noexcept;
VmaIntrusiveLinkedList(const VmaIntrusiveLinkedList&) = delete;
- VmaIntrusiveLinkedList& operator=(VmaIntrusiveLinkedList&& src);
+ VmaIntrusiveLinkedList& operator=(VmaIntrusiveLinkedList&& src) noexcept;
VmaIntrusiveLinkedList& operator=(const VmaIntrusiveLinkedList&) = delete;
~VmaIntrusiveLinkedList() { VMA_HEAVY_ASSERT(IsEmpty()); }
@@ -5430,7 +5495,7 @@ private:
#ifndef _VMA_INTRUSIVE_LINKED_LIST_FUNCTIONS
template
-VmaIntrusiveLinkedList::VmaIntrusiveLinkedList(VmaIntrusiveLinkedList&& src)
+VmaIntrusiveLinkedList::VmaIntrusiveLinkedList(VmaIntrusiveLinkedList&& src) noexcept
: m_Front(src.m_Front), m_Back(src.m_Back), m_Count(src.m_Count)
{
src.m_Front = src.m_Back = VMA_NULL;
@@ -5438,7 +5503,7 @@ VmaIntrusiveLinkedList::VmaIntrusiveLinkedList(VmaIntrusiveLinke
}
template
-VmaIntrusiveLinkedList& VmaIntrusiveLinkedList::operator=(VmaIntrusiveLinkedList&& src)
+VmaIntrusiveLinkedList& VmaIntrusiveLinkedList::operator=(VmaIntrusiveLinkedList&& src) noexcept
{
if (&src != this)
{
@@ -5627,10 +5692,11 @@ void VmaIntrusiveLinkedList::RemoveAll()
class VmaStringBuilder
{
public:
- VmaStringBuilder(const VkAllocationCallbacks* allocationCallbacks) : m_Data(VmaStlAllocator(allocationCallbacks)) {}
+ explicit VmaStringBuilder(const VkAllocationCallbacks* allocationCallbacks) : m_Data(VmaStlAllocator(allocationCallbacks)) {}
~VmaStringBuilder() = default;
size_t GetLength() const { return m_Data.size(); }
+ // Returned string is not null-terminated!
const char* GetData() const { return m_Data.data(); }
void AddNewLine() { Add('\n'); }
void Add(char ch) { m_Data.push_back(ch); }
@@ -6225,7 +6291,7 @@ class VmaDeviceMemoryBlock
public:
VmaBlockMetadata* m_pMetadata;
- VmaDeviceMemoryBlock(VmaAllocator hAllocator);
+ explicit VmaDeviceMemoryBlock(VmaAllocator hAllocator);
~VmaDeviceMemoryBlock();
// Always call after construction.
@@ -6265,14 +6331,14 @@ public:
VkResult ValidateMagicValueAfterAllocation(VmaAllocator hAllocator, VkDeviceSize allocOffset, VkDeviceSize allocSize);
VkResult BindBufferMemory(
- const VmaAllocator hAllocator,
- const VmaAllocation hAllocation,
+ VmaAllocator hAllocator,
+ VmaAllocation hAllocation,
VkDeviceSize allocationLocalOffset,
VkBuffer hBuffer,
const void* pNext);
VkResult BindImageMemory(
- const VmaAllocator hAllocator,
- const VmaAllocation hAllocation,
+ VmaAllocator hAllocator,
+ VmaAllocation hAllocation,
VkDeviceSize allocationLocalOffset,
VkImage hImage,
const void* pNext);
@@ -6329,7 +6395,7 @@ public:
};
// This struct is allocated using VmaPoolAllocator.
- VmaAllocation_T(bool mappingAllowed);
+ explicit VmaAllocation_T(bool mappingAllowed);
~VmaAllocation_T();
void InitBlockAllocation(
@@ -6476,7 +6542,7 @@ class VmaDedicatedAllocationList
{
VMA_CLASS_NO_COPY_NO_MOVE(VmaDedicatedAllocationList)
public:
- VmaDedicatedAllocationList() {}
+ VmaDedicatedAllocationList() = default;
~VmaDedicatedAllocationList();
void Init(bool useMutex) { m_UseMutex = useMutex; }
@@ -6738,10 +6804,10 @@ protected:
size_t unusedRangeCount) const;
void PrintDetailedMap_Allocation(class VmaJsonWriter& json,
VkDeviceSize offset, VkDeviceSize size, void* userData) const;
- void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
+ static void PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
VkDeviceSize offset,
- VkDeviceSize size) const;
- void PrintDetailedMap_End(class VmaJsonWriter& json) const;
+ VkDeviceSize size);
+ static void PrintDetailedMap_End(class VmaJsonWriter& json);
#endif
private:
@@ -6836,7 +6902,7 @@ void VmaBlockMetadata::PrintDetailedMap_Allocation(class VmaJsonWriter& json,
}
void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
- VkDeviceSize offset, VkDeviceSize size) const
+ VkDeviceSize offset, VkDeviceSize size)
{
json.BeginObject(true);
@@ -6852,7 +6918,7 @@ void VmaBlockMetadata::PrintDetailedMap_UnusedRange(class VmaJsonWriter& json,
json.EndObject();
}
-void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json) const
+void VmaBlockMetadata::PrintDetailedMap_End(class VmaJsonWriter& json)
{
json.EndArray();
}
@@ -6871,7 +6937,7 @@ public:
uint16_t* pageAllocs;
};
- VmaBlockBufferImageGranularity(VkDeviceSize bufferImageGranularity);
+ explicit VmaBlockBufferImageGranularity(VkDeviceSize bufferImageGranularity);
~VmaBlockBufferImageGranularity();
bool IsEnabled() const { return m_BufferImageGranularity > MAX_LOW_BUFFER_IMAGE_GRANULARITY; }
@@ -6916,7 +6982,7 @@ private:
uint32_t GetEndPage(VkDeviceSize offset, VkDeviceSize size) const { return OffsetToPageIndex((offset + size - 1) & ~(m_BufferImageGranularity - 1)); }
uint32_t OffsetToPageIndex(VkDeviceSize offset) const;
- void AllocPage(RegionInfo& page, uint8_t allocType);
+ static void AllocPage(RegionInfo& page, uint8_t allocType);
};
#ifndef _VMA_BLOCK_BUFFER_IMAGE_GRANULARITY_FUNCTIONS
@@ -7180,7 +7246,7 @@ class VmaBlockMetadata_Linear : public VmaBlockMetadata
public:
VmaBlockMetadata_Linear(const VkAllocationCallbacks* pAllocationCallbacks,
VkDeviceSize bufferImageGranularity, bool isVirtual);
- virtual ~VmaBlockMetadata_Linear() = default;
+ ~VmaBlockMetadata_Linear() override = default;
VkDeviceSize GetSumFreeSize() const override { return m_SumFreeSize; }
bool IsEmpty() const override { return GetAllocationCount() == 0; }
@@ -8795,7 +8861,7 @@ class VmaBlockMetadata_TLSF : public VmaBlockMetadata
public:
VmaBlockMetadata_TLSF(const VkAllocationCallbacks* pAllocationCallbacks,
VkDeviceSize bufferImageGranularity, bool isVirtual);
- virtual ~VmaBlockMetadata_TLSF();
+ ~VmaBlockMetadata_TLSF() override;
size_t GetAllocationCount() const override { return m_AllocCount; }
size_t GetFreeRegionsCount() const override { return m_BlocksFreeCount + 1; }
@@ -8889,7 +8955,7 @@ private:
Block* m_NullBlock;
VmaBlockBufferImageGranularity m_GranularityHandler;
- uint8_t SizeToMemoryClass(VkDeviceSize size) const;
+ static uint8_t SizeToMemoryClass(VkDeviceSize size);
uint16_t SizeToSecondIndex(VkDeviceSize size, uint8_t memoryClass) const;
uint32_t GetListIndex(uint8_t memoryClass, uint16_t secondIndex) const;
uint32_t GetListIndex(VkDeviceSize size) const;
@@ -9146,7 +9212,7 @@ bool VmaBlockMetadata_TLSF::CreateAllocationRequest(
// Round up to the next block
VkDeviceSize sizeForNextList = allocSize;
- VkDeviceSize smallSizeStep = VkDeviceSize(SMALL_BUFFER_SIZE / (IsVirtual() ? 1 << SECOND_LEVEL_INDEX : 4));
+ VkDeviceSize smallSizeStep = VkDeviceSize(SMALL_BUFFER_SIZE / (IsVirtual() ? 1U << SECOND_LEVEL_INDEX : 4U));
if (allocSize > SMALL_BUFFER_SIZE)
{
sizeForNextList += (1ULL << (VMA_BITSCAN_MSB(allocSize) - SECOND_LEVEL_INDEX));
@@ -9552,7 +9618,7 @@ void VmaBlockMetadata_TLSF::DebugLogAllAllocations() const
DebugLogAllocation(block->offset, block->size, block->UserData());
}
-uint8_t VmaBlockMetadata_TLSF::SizeToMemoryClass(VkDeviceSize size) const
+uint8_t VmaBlockMetadata_TLSF::SizeToMemoryClass(VkDeviceSize size)
{
if (size > SMALL_BUFFER_SIZE)
return uint8_t(VMA_BITSCAN_MSB(size) - MEMORY_CLASS_SHIFT);
@@ -9565,8 +9631,7 @@ uint16_t VmaBlockMetadata_TLSF::SizeToSecondIndex(VkDeviceSize size, uint8_t mem
{
if (IsVirtual())
return static_cast((size - 1) / 8);
- else
- return static_cast((size - 1) / 64);
+ return static_cast((size - 1) / 64);
}
return static_cast((size >> (memoryClass + MEMORY_CLASS_SHIFT - SECOND_LEVEL_INDEX)) ^ (1U << SECOND_LEVEL_INDEX));
}
@@ -9579,8 +9644,7 @@ uint32_t VmaBlockMetadata_TLSF::GetListIndex(uint8_t memoryClass, uint16_t secon
const uint32_t index = static_cast(memoryClass - 1) * (1 << SECOND_LEVEL_INDEX) + secondIndex;
if (IsVirtual())
return index + (1 << SECOND_LEVEL_INDEX);
- else
- return index + 4;
+ return index + 4;
}
uint32_t VmaBlockMetadata_TLSF::GetListIndex(VkDeviceSize size) const
@@ -9777,7 +9841,7 @@ public:
size_t allocationCount,
VmaAllocation* pAllocations);
- void Free(const VmaAllocation hAllocation);
+ void Free(VmaAllocation hAllocation);
#if VMA_STATS_STRING_ENABLED
void PrintDetailedMap(class VmaJsonWriter& json);
@@ -9927,7 +9991,7 @@ private:
bool ComputeDefragmentation_Full(VmaBlockVector& vector);
bool ComputeDefragmentation_Extensive(VmaBlockVector& vector, size_t index);
- void UpdateVectorStatistics(VmaBlockVector& vector, StateBalanced& state);
+ static void UpdateVectorStatistics(VmaBlockVector& vector, StateBalanced& state);
bool MoveDataToFreeBlocks(VmaSuballocationType currentType,
VmaBlockVector& vector, size_t firstFreeBlock,
bool& texturePresent, bool& bufferPresent, bool& otherPresent);
@@ -10053,7 +10117,7 @@ class VmaAllocationObjectAllocator
{
VMA_CLASS_NO_COPY_NO_MOVE(VmaAllocationObjectAllocator)
public:
- VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks)
+ explicit VmaAllocationObjectAllocator(const VkAllocationCallbacks* pAllocationCallbacks)
: m_Allocator(pAllocationCallbacks, 1024) {}
template VmaAllocation Allocate(Types&&... args);
@@ -10086,10 +10150,9 @@ public:
const bool m_AllocationCallbacksSpecified;
const VkAllocationCallbacks m_AllocationCallbacks;
- VmaVirtualBlock_T(const VmaVirtualBlockCreateInfo& createInfo);
+ explicit VmaVirtualBlock_T(const VmaVirtualBlockCreateInfo& createInfo);
~VmaVirtualBlock_T();
- VkResult Init() { return VK_SUCCESS; }
bool IsEmpty() const { return m_Metadata->IsEmpty(); }
void Free(VmaVirtualAllocation allocation) { m_Metadata->Free((VmaAllocHandle)allocation); }
void SetAllocationUserData(VmaVirtualAllocation allocation, void* userData) { m_Metadata->SetAllocationUserData((VmaAllocHandle)allocation, userData); }
@@ -10255,7 +10318,7 @@ public:
VmaCurrentBudgetData m_Budget;
VMA_ATOMIC_UINT32 m_DeviceMemoryCount; // Total number of VkDeviceMemory objects.
- VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
+ explicit VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo);
VkResult Init(const VmaAllocatorCreateInfo* pCreateInfo);
~VmaAllocator_T();
@@ -10349,18 +10412,18 @@ public:
void PrintDetailedMap(class VmaJsonWriter& json);
#endif
- void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
- void GetAllocationInfo2(VmaAllocation hAllocation, VmaAllocationInfo2* pAllocationInfo);
+ static void GetAllocationInfo(VmaAllocation hAllocation, VmaAllocationInfo* pAllocationInfo);
+ static void GetAllocationInfo2(VmaAllocation hAllocation, VmaAllocationInfo2* pAllocationInfo);
VkResult CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPool* pPool);
void DestroyPool(VmaPool pool);
- void GetPoolStatistics(VmaPool pool, VmaStatistics* pPoolStats);
- void CalculatePoolStatistics(VmaPool pool, VmaDetailedStatistics* pPoolStats);
+ static void GetPoolStatistics(VmaPool pool, VmaStatistics* pPoolStats);
+ static void CalculatePoolStatistics(VmaPool pool, VmaDetailedStatistics* pPoolStats);
void SetCurrentFrameIndex(uint32_t frameIndex);
uint32_t GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
- VkResult CheckPoolCorruption(VmaPool hPool);
+ static VkResult CheckPoolCorruption(VmaPool hPool);
VkResult CheckCorruption(uint32_t memoryTypeBits);
// Call to Vulkan function vkAllocateMemory with accompanying bookkeeping.
@@ -10372,13 +10435,13 @@ public:
VkDeviceMemory memory,
VkDeviceSize memoryOffset,
VkBuffer buffer,
- const void* pNext);
+ const void* pNext) const;
// Call to Vulkan function vkBindImageMemory or vkBindImageMemory2KHR.
VkResult BindVulkanImage(
VkDeviceMemory memory,
VkDeviceSize memoryOffset,
VkImage image,
- const void* pNext);
+ const void* pNext) const;
VkResult Map(VmaAllocation hAllocation, void** ppData);
void Unmap(VmaAllocation hAllocation);
@@ -10415,7 +10478,7 @@ public:
void* pDstHostPointer,
VkDeviceSize size);
- void FillAllocation(const VmaAllocation hAllocation, uint8_t pattern);
+ void FillAllocation(VmaAllocation hAllocation, uint8_t pattern);
/*
Returns bit mask of memory types that can support defragmentation on GPU as
@@ -10463,7 +10526,7 @@ private:
void ImportVulkanFunctions_Dynamic();
#endif
- void ValidateVulkanFunctions();
+ void ValidateVulkanFunctions() const;
VkDeviceSize CalcPreferredBlockSize(uint32_t memTypeIndex);
@@ -10516,17 +10579,16 @@ private:
VmaAllocation* pAllocations,
const void* pNextChain = VMA_NULL);
- void FreeDedicatedMemory(const VmaAllocation allocation);
+ void FreeDedicatedMemory(VmaAllocation allocation);
VkResult CalcMemTypeParams(
VmaAllocationCreateInfo& outCreateInfo,
uint32_t memTypeIndex,
VkDeviceSize size,
size_t allocationCount);
- VkResult CalcAllocationParams(
+ static VkResult CalcAllocationParams(
VmaAllocationCreateInfo& outCreateInfo,
- bool dedicatedRequired,
- bool dedicatedPreferred);
+ bool dedicatedRequired);
/*
Calculates and returns bit mask of memory types that can support defragmentation
@@ -10594,6 +10656,7 @@ static void vma_delete_array(VmaAllocator hAllocator, T* ptr, size_t count)
#ifndef _VMA_DEVICE_MEMORY_BLOCK_FUNCTIONS
VmaDeviceMemoryBlock::VmaDeviceMemoryBlock(VmaAllocator hAllocator)
: m_pMetadata(VMA_NULL),
+ m_hParentPool(nullptr),
m_MemoryTypeIndex(UINT32_MAX),
m_Id(0),
m_hMemory(VK_NULL_HANDLE),
@@ -10723,27 +10786,25 @@ VkResult VmaDeviceMemoryBlock::Map(VmaAllocator hAllocator, uint32_t count, void
}
return VK_SUCCESS;
}
- else
+
+ VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
+ hAllocator->m_hDevice,
+ m_hMemory,
+ 0, // offset
+ VK_WHOLE_SIZE,
+ 0, // flags
+ &m_pMappedData);
+ if (result == VK_SUCCESS)
{
- VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
- hAllocator->m_hDevice,
- m_hMemory,
- 0, // offset
- VK_WHOLE_SIZE,
- 0, // flags
- &m_pMappedData);
- if (result == VK_SUCCESS)
+ VMA_ASSERT(m_pMappedData != VMA_NULL);
+ m_MappingHysteresis.PostMap();
+ m_MapCount = count;
+ if (ppData != VMA_NULL)
{
- VMA_ASSERT(m_pMappedData != VMA_NULL);
- m_MappingHysteresis.PostMap();
- m_MapCount = count;
- if (ppData != VMA_NULL)
- {
- *ppData = m_pMappedData;
- }
+ *ppData = m_pMappedData;
}
- return result;
}
+ return result;
}
void VmaDeviceMemoryBlock::Unmap(VmaAllocator hAllocator, uint32_t count)
@@ -10775,7 +10836,7 @@ VkResult VmaDeviceMemoryBlock::WriteMagicValueAfterAllocation(VmaAllocator hAllo
{
VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
- void* pData;
+ void* pData = VMA_NULL;
VkResult res = Map(hAllocator, 1, &pData);
if (res != VK_SUCCESS)
{
@@ -10792,7 +10853,7 @@ VkResult VmaDeviceMemoryBlock::ValidateMagicValueAfterAllocation(VmaAllocator hA
{
VMA_ASSERT(VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_MARGIN % 4 == 0 && VMA_DEBUG_DETECT_CORRUPTION);
- void* pData;
+ void* pData = VMA_NULL;
VkResult res = Map(hAllocator, 1, &pData);
if (res != VK_SUCCESS)
{
@@ -10809,8 +10870,8 @@ VkResult VmaDeviceMemoryBlock::ValidateMagicValueAfterAllocation(VmaAllocator hA
}
VkResult VmaDeviceMemoryBlock::BindBufferMemory(
- const VmaAllocator hAllocator,
- const VmaAllocation hAllocation,
+ VmaAllocator hAllocator,
+ VmaAllocation hAllocation,
VkDeviceSize allocationLocalOffset,
VkBuffer hBuffer,
const void* pNext)
@@ -10826,8 +10887,8 @@ VkResult VmaDeviceMemoryBlock::BindBufferMemory(
}
VkResult VmaDeviceMemoryBlock::BindImageMemory(
- const VmaAllocator hAllocator,
- const VmaAllocation hAllocation,
+ VmaAllocator hAllocator,
+ VmaAllocation hAllocation,
VkDeviceSize allocationLocalOffset,
VkImage hImage,
const void* pNext)
@@ -11097,28 +11158,24 @@ VkResult VmaAllocation_T::DedicatedAllocMap(VmaAllocator hAllocator, void** ppDa
++m_MapCount;
return VK_SUCCESS;
}
- else
- {
- VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
- return VK_ERROR_MEMORY_MAP_FAILED;
- }
+
+ VMA_ASSERT(0 && "Dedicated allocation mapped too many times simultaneously.");
+ return VK_ERROR_MEMORY_MAP_FAILED;
}
- else
+
+ VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
+ hAllocator->m_hDevice,
+ m_DedicatedAllocation.m_hMemory,
+ 0, // offset
+ VK_WHOLE_SIZE,
+ 0, // flags
+ ppData);
+ if (result == VK_SUCCESS)
{
- VkResult result = (*hAllocator->GetVulkanFunctions().vkMapMemory)(
- hAllocator->m_hDevice,
- m_DedicatedAllocation.m_hMemory,
- 0, // offset
- VK_WHOLE_SIZE,
- 0, // flags
- ppData);
- if (result == VK_SUCCESS)
- {
- m_DedicatedAllocation.m_ExtraData->m_pMappedData = *ppData;
- m_MapCount = 1;
- }
- return result;
+ m_DedicatedAllocation.m_ExtraData->m_pMappedData = *ppData;
+ m_MapCount = 1;
}
+ return result;
}
void VmaAllocation_T::DedicatedAllocUnmap(VmaAllocator hAllocator)
@@ -11306,7 +11363,7 @@ VkResult VmaBlockVector::Allocate(
size_t allocationCount,
VmaAllocation* pAllocations)
{
- size_t allocIndex;
+ size_t allocIndex = 0;
VkResult res = VK_SUCCESS;
alignment = VMA_MAX(alignment, m_MinAllocationAlignment);
@@ -11319,7 +11376,7 @@ VkResult VmaBlockVector::Allocate(
{
VmaMutexLockWrite lock(m_Mutex, m_hAllocator->m_UseMutex);
- for (allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+ for (; allocIndex < allocationCount; ++allocIndex)
{
res = AllocatePage(
size,
@@ -11354,7 +11411,7 @@ VkResult VmaBlockVector::AllocatePage(
{
const bool isUpperAddress = (createInfo.flags & VMA_ALLOCATION_CREATE_UPPER_ADDRESS_BIT) != 0;
- VkDeviceSize freeMemory;
+ VkDeviceSize freeMemory = 0;
{
const uint32_t heapIndex = m_hAllocator->MemoryTypeIndexToHeapIndex(m_MemoryTypeIndex);
VmaBudget heapBudget = {};
@@ -11538,18 +11595,16 @@ VkResult VmaBlockVector::AllocatePage(
IncrementallySortBlocks();
return VK_SUCCESS;
}
- else
- {
- // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
- return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- }
+
+ // Allocation from new block failed, possibly due to VMA_DEBUG_MARGIN or alignment.
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
}
}
return VK_ERROR_OUT_OF_DEVICE_MEMORY;
}
-void VmaBlockVector::Free(const VmaAllocation hAllocation)
+void VmaBlockVector::Free(VmaAllocation hAllocation)
{
VmaDeviceMemoryBlock* pBlockToDelete = VMA_NULL;
@@ -11780,7 +11835,7 @@ VkResult VmaBlockVector::CreateBlock(VkDeviceSize blockSize, size_t* pNewBlockIn
VkMemoryPriorityAllocateInfoEXT priorityInfo = { VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT };
if (m_hAllocator->m_UseExtMemoryPriority)
{
- VMA_ASSERT(m_Priority >= 0.f && m_Priority <= 1.f);
+ VMA_ASSERT(m_Priority >= 0.F && m_Priority <= 1.F);
priorityInfo.priority = m_Priority;
VmaPnextChainPushFront(&allocInfo, &priorityInfo);
}
@@ -11895,10 +11950,9 @@ VmaDefragmentationContext_T::VmaDefragmentationContext_T(
m_BreakCallback(info.pfnBreakCallback),
m_BreakCallbackUserData(info.pBreakCallbackUserData),
m_MoveAllocator(hAllocator->GetAllocationCallbacks()),
- m_Moves(m_MoveAllocator)
+ m_Moves(m_MoveAllocator),
+ m_Algorithm(info.flags & VMA_DEFRAGMENTATION_FLAG_ALGORITHM_MASK)
{
- m_Algorithm = info.flags & VMA_DEFRAGMENTATION_FLAG_ALGORITHM_MASK;
-
if (info.pool != VMA_NULL)
{
m_BlockVectorCount = 1;
@@ -11938,6 +11992,8 @@ VmaDefragmentationContext_T::VmaDefragmentationContext_T(
m_AlgorithmState = vma_new_array(hAllocator, StateExtensive, m_BlockVectorCount);
}
break;
+ default:
+ ; // Do nothing.
}
}
@@ -12030,14 +12086,14 @@ VkResult VmaDefragmentationContext_T::DefragmentPassEnd(VmaDefragmentationPassMo
for (uint32_t i = 0; i < moveInfo.moveCount; ++i)
{
VmaDefragmentationMove& move = moveInfo.pMoves[i];
- size_t prevCount = 0, currentCount = 0;
+ size_t prevCount = 0;
+ size_t currentCount = 0;
VkDeviceSize freedBlockSize = 0;
- uint32_t vectorIndex;
- VmaBlockVector* vector;
+ uint32_t vectorIndex = 0;
+ VmaBlockVector* vector = VMA_NULL;
if (m_PoolBlockVector != VMA_NULL)
{
- vectorIndex = 0;
vector = m_PoolBlockVector;
}
else
@@ -12122,7 +12178,7 @@ VkResult VmaDefragmentationContext_T::DefragmentPassEnd(VmaDefragmentationPassMo
}
freedBlockSize *= prevCount - currentCount;
- VkDeviceSize dstBlockSize;
+ VkDeviceSize dstBlockSize = SIZE_MAX;
{
VmaMutexLockRead lock(vector->GetMutex(), vector->GetAllocator()->m_UseMutex);
dstBlockSize = move.dstTmpAllocation->GetBlock()->m_pMetadata->GetSize();
@@ -12179,7 +12235,7 @@ VkResult VmaDefragmentationContext_T::DefragmentPassEnd(VmaDefragmentationPassMo
m_PassStats = { 0 };
// Move blocks with immovable allocations according to algorithm
- if (immovableBlocks.size() > 0)
+ if (!immovableBlocks.empty())
{
do
{
@@ -12298,11 +12354,10 @@ VmaDefragmentationContext_T::CounterStatus VmaDefragmentationContext_T::CheckCou
{
if (++m_IgnoredAllocs < MAX_ALLOCS_TO_IGNORE)
return CounterStatus::Ignore;
- else
- return CounterStatus::End;
+ return CounterStatus::End;
}
- else
- m_IgnoredAllocs = 0;
+
+ m_IgnoredAllocs = 0;
return CounterStatus::Pass;
}
@@ -12619,7 +12674,9 @@ bool VmaDefragmentationContext_T::ComputeDefragmentation_Extensive(VmaBlockVecto
StateExtensive& vectorState = reinterpret_cast(m_AlgorithmState)[index];
- bool texturePresent = false, bufferPresent = false, otherPresent = false;
+ bool texturePresent = false;
+ bool bufferPresent = false;
+ bool otherPresent = false;
switch (vectorState.operation)
{
case StateExtensive::Operation::Done: // Vector defragmented
@@ -13071,7 +13128,7 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
const VkDeviceSize limit = pCreateInfo->pHeapSizeLimit[heapIndex];
if(limit != VK_WHOLE_SIZE)
{
- m_HeapSizeLimitMask |= 1u << heapIndex;
+ m_HeapSizeLimitMask |= 1U << heapIndex;
if(limit < m_MemProps.memoryHeaps[heapIndex].size)
{
m_MemProps.memoryHeaps[heapIndex].size = limit;
@@ -13083,7 +13140,7 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
for(uint32_t memTypeIndex = 0; memTypeIndex < GetMemoryTypeCount(); ++memTypeIndex)
{
// Create only supported types
- if((m_GlobalMemoryTypeBits & (1u << memTypeIndex)) != 0)
+ if((m_GlobalMemoryTypeBits & (1U << memTypeIndex)) != 0)
{
const VkDeviceSize preferredBlockSize = CalcPreferredBlockSize(memTypeIndex);
m_pBlockVectors[memTypeIndex] = vma_new(this, VmaBlockVector)(
@@ -13096,7 +13153,7 @@ VmaAllocator_T::VmaAllocator_T(const VmaAllocatorCreateInfo* pCreateInfo) :
GetBufferImageGranularity(),
false, // explicitBlockSize
0, // algorithm
- 0.5f, // priority (0.5 is the default per Vulkan spec)
+ 0.5F, // priority (0.5 is the default per Vulkan spec)
GetMemoryTypeMinAlignment(memTypeIndex), // minAllocationAlignment
VMA_NULL); // // pMemoryAllocateNext
// No need to call m_pBlockVectors[memTypeIndex][blockVectorTypeIndex]->CreateMinBlocks here,
@@ -13366,7 +13423,7 @@ void VmaAllocator_T::ImportVulkanFunctions_Dynamic()
#endif // VMA_DYNAMIC_VULKAN_FUNCTIONS == 1
-void VmaAllocator_T::ValidateVulkanFunctions()
+void VmaAllocator_T::ValidateVulkanFunctions() const
{
VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceProperties != VMA_NULL);
VMA_ASSERT(m_VulkanFunctions.vkGetPhysicalDeviceMemoryProperties != VMA_NULL);
@@ -13481,70 +13538,28 @@ VkResult VmaAllocator_T::AllocateMemoryOfType(
pAllocations,
blockVector.GetAllocationNextPtr());
}
- else
+
+ const bool canAllocateDedicated =
+ (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
+ (pool == VK_NULL_HANDLE || !blockVector.HasExplicitBlockSize());
+
+ if(canAllocateDedicated)
{
- const bool canAllocateDedicated =
- (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_NEVER_ALLOCATE_BIT) == 0 &&
- (pool == VK_NULL_HANDLE || !blockVector.HasExplicitBlockSize());
-
- if(canAllocateDedicated)
+ // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
+ if(size > blockVector.GetPreferredBlockSize() / 2)
{
- // Heuristics: Allocate dedicated memory if requested size if greater than half of preferred block size.
- if(size > blockVector.GetPreferredBlockSize() / 2)
- {
- dedicatedPreferred = true;
- }
- // Protection against creating each allocation as dedicated when we reach or exceed heap size/budget,
- // which can quickly deplete maxMemoryAllocationCount: Don't prefer dedicated allocations when above
- // 3/4 of the maximum allocation count.
- if(m_PhysicalDeviceProperties.limits.maxMemoryAllocationCount < UINT32_MAX / 4 &&
- m_DeviceMemoryCount.load() > m_PhysicalDeviceProperties.limits.maxMemoryAllocationCount * 3 / 4)
- {
- dedicatedPreferred = false;
- }
-
- if(dedicatedPreferred)
- {
- res = AllocateDedicatedMemory(
- pool,
- size,
- suballocType,
- dedicatedAllocations,
- memTypeIndex,
- (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
- (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
- (finalCreateInfo.flags &
- (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0,
- (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT) != 0,
- finalCreateInfo.pUserData,
- finalCreateInfo.priority,
- dedicatedBuffer,
- dedicatedImage,
- dedicatedBufferImageUsage,
- allocationCount,
- pAllocations,
- blockVector.GetAllocationNextPtr());
- if(res == VK_SUCCESS)
- {
- // Succeeded: AllocateDedicatedMemory function already filled pMemory, nothing more to do here.
- VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
- return VK_SUCCESS;
- }
- }
+ dedicatedPreferred = true;
+ }
+ // Protection against creating each allocation as dedicated when we reach or exceed heap size/budget,
+ // which can quickly deplete maxMemoryAllocationCount: Don't prefer dedicated allocations when above
+ // 3/4 of the maximum allocation count.
+ if(m_PhysicalDeviceProperties.limits.maxMemoryAllocationCount < UINT32_MAX / 4 &&
+ m_DeviceMemoryCount.load() > m_PhysicalDeviceProperties.limits.maxMemoryAllocationCount * 3 / 4)
+ {
+ dedicatedPreferred = false;
}
- res = blockVector.Allocate(
- size,
- alignment,
- finalCreateInfo,
- suballocType,
- allocationCount,
- pAllocations);
- if(res == VK_SUCCESS)
- return VK_SUCCESS;
-
- // Try dedicated memory.
- if(canAllocateDedicated && !dedicatedPreferred)
+ if(dedicatedPreferred)
{
res = AllocateDedicatedMemory(
pool,
@@ -13572,10 +13587,50 @@ VkResult VmaAllocator_T::AllocateMemoryOfType(
return VK_SUCCESS;
}
}
- // Everything failed: Return error code.
- VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
- return res;
}
+
+ res = blockVector.Allocate(
+ size,
+ alignment,
+ finalCreateInfo,
+ suballocType,
+ allocationCount,
+ pAllocations);
+ if(res == VK_SUCCESS)
+ return VK_SUCCESS;
+
+ // Try dedicated memory.
+ if(canAllocateDedicated && !dedicatedPreferred)
+ {
+ res = AllocateDedicatedMemory(
+ pool,
+ size,
+ suballocType,
+ dedicatedAllocations,
+ memTypeIndex,
+ (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_MAPPED_BIT) != 0,
+ (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_USER_DATA_COPY_STRING_BIT) != 0,
+ (finalCreateInfo.flags &
+ (VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) != 0,
+ (finalCreateInfo.flags & VMA_ALLOCATION_CREATE_CAN_ALIAS_BIT) != 0,
+ finalCreateInfo.pUserData,
+ finalCreateInfo.priority,
+ dedicatedBuffer,
+ dedicatedImage,
+ dedicatedBufferImageUsage,
+ allocationCount,
+ pAllocations,
+ blockVector.GetAllocationNextPtr());
+ if(res == VK_SUCCESS)
+ {
+ // Succeeded: AllocateDedicatedMemory function already filled pMemory, nothing more to do here.
+ VMA_DEBUG_LOG(" Allocated as DedicatedMemory");
+ return VK_SUCCESS;
+ }
+ }
+ // Everything failed: Return error code.
+ VMA_DEBUG_LOG(" vkAllocateMemory FAILED");
+ return res;
}
VkResult VmaAllocator_T::AllocateDedicatedMemory(
@@ -13651,7 +13706,7 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory(
VkMemoryPriorityAllocateInfoEXT priorityInfo = { VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT };
if(m_UseExtMemoryPriority)
{
- VMA_ASSERT(priority >= 0.f && priority <= 1.f);
+ VMA_ASSERT(priority >= 0.F && priority <= 1.F);
priorityInfo.priority = priority;
VmaPnextChainPushFront(&allocInfo, &priorityInfo);
}
@@ -13667,9 +13722,9 @@ VkResult VmaAllocator_T::AllocateDedicatedMemory(
}
#endif // #if VMA_EXTERNAL_MEMORY
- size_t allocIndex;
+ size_t allocIndex = 0;
VkResult res = VK_SUCCESS;
- for(allocIndex = 0; allocIndex < allocationCount; ++allocIndex)
+ for(; allocIndex < allocationCount; ++allocIndex)
{
res = AllocateDedicatedMemoryPage(
pool,
@@ -13855,7 +13910,9 @@ VkResult VmaAllocator_T::FindMemoryTypeIndex(
memoryTypeBits &= pAllocationCreateInfo->memoryTypeBits;
}
- VkMemoryPropertyFlags requiredFlags = 0, preferredFlags = 0, notPreferredFlags = 0;
+ VkMemoryPropertyFlags requiredFlags = 0;
+ VkMemoryPropertyFlags preferredFlags = 0;
+ VkMemoryPropertyFlags notPreferredFlags = 0;
if(!FindMemoryPreferences(
IsIntegratedGpu(),
*pAllocationCreateInfo,
@@ -13927,8 +13984,7 @@ VkResult VmaAllocator_T::CalcMemTypeParams(
VkResult VmaAllocator_T::CalcAllocationParams(
VmaAllocationCreateInfo& inoutCreateInfo,
- bool dedicatedRequired,
- bool dedicatedPreferred)
+ bool dedicatedRequired)
{
VMA_ASSERT((inoutCreateInfo.flags &
(VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT)) !=
@@ -14016,7 +14072,7 @@ VkResult VmaAllocator_T::AllocateMemory(
}
VmaAllocationCreateInfo createInfoFinal = createInfo;
- VkResult res = CalcAllocationParams(createInfoFinal, requiresDedicatedAllocation, prefersDedicatedAllocation);
+ VkResult res = CalcAllocationParams(createInfoFinal, requiresDedicatedAllocation);
if(res != VK_SUCCESS)
return res;
@@ -14039,48 +14095,47 @@ VkResult VmaAllocator_T::AllocateMemory(
allocationCount,
pAllocations);
}
- else
+
+ // Bit mask of memory Vulkan types acceptable for this allocation.
+ uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
+ uint32_t memTypeIndex = UINT32_MAX;
+ res = FindMemoryTypeIndex(memoryTypeBits, &createInfoFinal, dedicatedBufferImageUsage, &memTypeIndex);
+ // Can't find any single memory type matching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
+ if(res != VK_SUCCESS)
+ return res;
+
+ do
{
- // Bit mask of memory Vulkan types acceptable for this allocation.
- uint32_t memoryTypeBits = vkMemReq.memoryTypeBits;
- uint32_t memTypeIndex = UINT32_MAX;
+ VmaBlockVector* blockVector = m_pBlockVectors[memTypeIndex];
+ VMA_ASSERT(blockVector && "Trying to use unsupported memory type!");
+ res = AllocateMemoryOfType(
+ VK_NULL_HANDLE,
+ vkMemReq.size,
+ vkMemReq.alignment,
+ requiresDedicatedAllocation || prefersDedicatedAllocation,
+ dedicatedBuffer,
+ dedicatedImage,
+ dedicatedBufferImageUsage,
+ createInfoFinal,
+ memTypeIndex,
+ suballocType,
+ m_DedicatedAllocations[memTypeIndex],
+ *blockVector,
+ allocationCount,
+ pAllocations);
+ // Allocation succeeded
+ if(res == VK_SUCCESS)
+ return VK_SUCCESS;
+
+ // Remove old memTypeIndex from list of possibilities.
+ memoryTypeBits &= ~(1U << memTypeIndex);
+ // Find alternative memTypeIndex.
res = FindMemoryTypeIndex(memoryTypeBits, &createInfoFinal, dedicatedBufferImageUsage, &memTypeIndex);
- // Can't find any single memory type matching requirements. res is VK_ERROR_FEATURE_NOT_PRESENT.
- if(res != VK_SUCCESS)
- return res;
- do
- {
- VmaBlockVector* blockVector = m_pBlockVectors[memTypeIndex];
- VMA_ASSERT(blockVector && "Trying to use unsupported memory type!");
- res = AllocateMemoryOfType(
- VK_NULL_HANDLE,
- vkMemReq.size,
- vkMemReq.alignment,
- requiresDedicatedAllocation || prefersDedicatedAllocation,
- dedicatedBuffer,
- dedicatedImage,
- dedicatedBufferImageUsage,
- createInfoFinal,
- memTypeIndex,
- suballocType,
- m_DedicatedAllocations[memTypeIndex],
- *blockVector,
- allocationCount,
- pAllocations);
- // Allocation succeeded
- if(res == VK_SUCCESS)
- return VK_SUCCESS;
+ } while(res == VK_SUCCESS);
- // Remove old memTypeIndex from list of possibilities.
- memoryTypeBits &= ~(1u << memTypeIndex);
- // Find alternative memTypeIndex.
- res = FindMemoryTypeIndex(memoryTypeBits, &createInfoFinal, dedicatedBufferImageUsage, &memTypeIndex);
- } while(res == VK_SUCCESS);
-
- // No other matching memory type index could be found.
- // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
- return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- }
+ // No other matching memory type index could be found.
+ // Not returning res, which is VK_ERROR_FEATURE_NOT_PRESENT, because we already failed to allocate once.
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
}
void VmaAllocator_T::FreeMemory(
@@ -14289,7 +14344,7 @@ VkResult VmaAllocator_T::CreatePool(const VmaPoolCreateInfo* pCreateInfo, VmaPoo
}
// Memory type index out of range or forbidden.
if(pCreateInfo->memoryTypeIndex >= GetMemoryTypeCount() ||
- ((1u << pCreateInfo->memoryTypeIndex) & m_GlobalMemoryTypeBits) == 0)
+ ((1U << pCreateInfo->memoryTypeIndex) & m_GlobalMemoryTypeBits) == 0)
{
return VK_ERROR_FEATURE_NOT_PRESENT;
}
@@ -14391,7 +14446,7 @@ VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
VmaMutexLockRead lock(m_PoolsMutex, m_UseMutex);
for(VmaPool pool = m_Pools.Front(); pool != VMA_NULL; pool = m_Pools.GetNext(pool))
{
- if(((1u << pool->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
+ if(((1U << pool->m_BlockVector.GetMemoryTypeIndex()) & memoryTypeBits) != 0)
{
VkResult localRes = pool->m_BlockVector.CheckCorruption();
switch(localRes)
@@ -14413,6 +14468,15 @@ VkResult VmaAllocator_T::CheckCorruption(uint32_t memoryTypeBits)
VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkDeviceMemory* pMemory)
{
+ const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
+
+#if VMA_DEBUG_DONT_EXCEED_HEAP_SIZE_WITH_ALLOCATION_SIZE
+ if (pAllocateInfo->allocationSize > m_MemProps.memoryHeaps[heapIndex].size)
+ {
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
+#endif
+
AtomicTransactionalIncrement deviceMemoryCountIncrement;
const uint64_t prevDeviceMemoryCount = deviceMemoryCountIncrement.Increment(&m_DeviceMemoryCount);
#if VMA_DEBUG_DONT_EXCEED_MAX_MEMORY_ALLOCATION_COUNT
@@ -14422,10 +14486,8 @@ VkResult VmaAllocator_T::AllocateVulkanMemory(const VkMemoryAllocateInfo* pAlloc
}
#endif
- const uint32_t heapIndex = MemoryTypeIndexToHeapIndex(pAllocateInfo->memoryTypeIndex);
-
// HeapSizeLimit is in effect for this heap.
- if((m_HeapSizeLimitMask & (1u << heapIndex)) != 0)
+ if((m_HeapSizeLimitMask & (1U << heapIndex)) != 0)
{
const VkDeviceSize heapSize = m_MemProps.memoryHeaps[heapIndex].size;
VkDeviceSize blockBytes = m_Budget.m_BlockBytes[heapIndex];
@@ -14496,7 +14558,7 @@ VkResult VmaAllocator_T::BindVulkanBuffer(
VkDeviceMemory memory,
VkDeviceSize memoryOffset,
VkBuffer buffer,
- const void* pNext)
+ const void* pNext) const
{
if(pNext != VMA_NULL)
{
@@ -14511,11 +14573,9 @@ VkResult VmaAllocator_T::BindVulkanBuffer(
bindBufferMemoryInfo.memoryOffset = memoryOffset;
return (*m_VulkanFunctions.vkBindBufferMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
}
- else
#endif // #if VMA_VULKAN_VERSION >= 1001000 || VMA_BIND_MEMORY2
- {
- return VK_ERROR_EXTENSION_NOT_PRESENT;
- }
+
+ return VK_ERROR_EXTENSION_NOT_PRESENT;
}
else
{
@@ -14527,7 +14587,7 @@ VkResult VmaAllocator_T::BindVulkanImage(
VkDeviceMemory memory,
VkDeviceSize memoryOffset,
VkImage image,
- const void* pNext)
+ const void* pNext) const
{
if(pNext != VMA_NULL)
{
@@ -14542,16 +14602,12 @@ VkResult VmaAllocator_T::BindVulkanImage(
bindBufferMemoryInfo.memoryOffset = memoryOffset;
return (*m_VulkanFunctions.vkBindImageMemory2KHR)(m_hDevice, 1, &bindBufferMemoryInfo);
}
- else
#endif // #if VMA_BIND_MEMORY2
- {
- return VK_ERROR_EXTENSION_NOT_PRESENT;
- }
- }
- else
- {
- return (*m_VulkanFunctions.vkBindImageMemory)(m_hDevice, image, memory, memoryOffset);
+
+ return VK_ERROR_EXTENSION_NOT_PRESENT;
}
+
+ return (*m_VulkanFunctions.vkBindImageMemory)(m_hDevice, image, memory, memoryOffset);
}
VkResult VmaAllocator_T::Map(VmaAllocation hAllocation, void** ppData)
@@ -14751,7 +14807,7 @@ VkResult VmaAllocator_T::CopyAllocationToMemory(
return res;
}
-void VmaAllocator_T::FreeDedicatedMemory(const VmaAllocation allocation)
+void VmaAllocator_T::FreeDedicatedMemory(VmaAllocation allocation)
{
VMA_ASSERT(allocation && allocation->GetType() == VmaAllocation_T::ALLOCATION_TYPE_DEDICATED);
@@ -14828,7 +14884,7 @@ uint32_t VmaAllocator_T::CalculateGlobalMemoryTypeBits() const
{
if((m_MemProps.memoryTypes[memTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD_COPY) != 0)
{
- memoryTypeBits &= ~(1u << memTypeIndex);
+ memoryTypeBits &= ~(1U << memTypeIndex);
}
}
}
@@ -14939,7 +14995,7 @@ void VmaAllocator_T::UpdateVulkanBudget()
}
#endif // VMA_MEMORY_BUDGET
-void VmaAllocator_T::FillAllocation(const VmaAllocation hAllocation, uint8_t pattern)
+void VmaAllocator_T::FillAllocation(VmaAllocation hAllocation, uint8_t pattern)
{
if(VMA_DEBUG_INITIALIZE_ALLOCATIONS &&
hAllocation->IsMappingAllowed() &&
@@ -15064,6 +15120,103 @@ void VmaAllocator_T::PrintDetailedMap(VmaJsonWriter& json)
#ifndef _VMA_PUBLIC_INTERFACE
+
+#ifdef VOLK_HEADER_VERSION
+
+VMA_CALL_PRE VkResult VMA_CALL_POST vmaImportVulkanFunctionsFromVolk(
+ const VmaAllocatorCreateInfo* VMA_NOT_NULL pAllocatorCreateInfo,
+ VmaVulkanFunctions* VMA_NOT_NULL pDstVulkanFunctions)
+{
+ VMA_ASSERT(pAllocatorCreateInfo != VMA_NULL);
+ VMA_ASSERT(pAllocatorCreateInfo->instance != VK_NULL_HANDLE);
+ VMA_ASSERT(pAllocatorCreateInfo->device != VK_NULL_HANDLE);
+
+ memset(pDstVulkanFunctions, 0, sizeof(*pDstVulkanFunctions));
+
+ VolkDeviceTable src = {};
+ volkLoadDeviceTable(&src, pAllocatorCreateInfo->device);
+
+#define COPY_GLOBAL_TO_VMA_FUNC(volkName, vmaName) if(!pDstVulkanFunctions->vmaName) pDstVulkanFunctions->vmaName = volkName;
+#define COPY_DEVICE_TO_VMA_FUNC(volkName, vmaName) if(!pDstVulkanFunctions->vmaName) pDstVulkanFunctions->vmaName = src.volkName;
+
+ COPY_GLOBAL_TO_VMA_FUNC(vkGetInstanceProcAddr, vkGetInstanceProcAddr)
+ COPY_GLOBAL_TO_VMA_FUNC(vkGetDeviceProcAddr, vkGetDeviceProcAddr)
+ COPY_GLOBAL_TO_VMA_FUNC(vkGetPhysicalDeviceProperties, vkGetPhysicalDeviceProperties)
+ COPY_GLOBAL_TO_VMA_FUNC(vkGetPhysicalDeviceMemoryProperties, vkGetPhysicalDeviceMemoryProperties)
+ COPY_DEVICE_TO_VMA_FUNC(vkAllocateMemory, vkAllocateMemory)
+ COPY_DEVICE_TO_VMA_FUNC(vkFreeMemory, vkFreeMemory)
+ COPY_DEVICE_TO_VMA_FUNC(vkMapMemory, vkMapMemory)
+ COPY_DEVICE_TO_VMA_FUNC(vkUnmapMemory, vkUnmapMemory)
+ COPY_DEVICE_TO_VMA_FUNC(vkFlushMappedMemoryRanges, vkFlushMappedMemoryRanges)
+ COPY_DEVICE_TO_VMA_FUNC(vkInvalidateMappedMemoryRanges, vkInvalidateMappedMemoryRanges)
+ COPY_DEVICE_TO_VMA_FUNC(vkBindBufferMemory, vkBindBufferMemory)
+ COPY_DEVICE_TO_VMA_FUNC(vkBindImageMemory, vkBindImageMemory)
+ COPY_DEVICE_TO_VMA_FUNC(vkGetBufferMemoryRequirements, vkGetBufferMemoryRequirements)
+ COPY_DEVICE_TO_VMA_FUNC(vkGetImageMemoryRequirements, vkGetImageMemoryRequirements)
+ COPY_DEVICE_TO_VMA_FUNC(vkCreateBuffer, vkCreateBuffer)
+ COPY_DEVICE_TO_VMA_FUNC(vkDestroyBuffer, vkDestroyBuffer)
+ COPY_DEVICE_TO_VMA_FUNC(vkCreateImage, vkCreateImage)
+ COPY_DEVICE_TO_VMA_FUNC(vkDestroyImage, vkDestroyImage)
+ COPY_DEVICE_TO_VMA_FUNC(vkCmdCopyBuffer, vkCmdCopyBuffer)
+#if VMA_VULKAN_VERSION >= 1001000
+ if (pAllocatorCreateInfo->vulkanApiVersion >= VK_MAKE_VERSION(1, 1, 0))
+ {
+ COPY_GLOBAL_TO_VMA_FUNC(vkGetPhysicalDeviceMemoryProperties2, vkGetPhysicalDeviceMemoryProperties2KHR)
+ COPY_DEVICE_TO_VMA_FUNC(vkGetBufferMemoryRequirements2, vkGetBufferMemoryRequirements2KHR)
+ COPY_DEVICE_TO_VMA_FUNC(vkGetImageMemoryRequirements2, vkGetImageMemoryRequirements2KHR)
+ COPY_DEVICE_TO_VMA_FUNC(vkBindBufferMemory2, vkBindBufferMemory2KHR)
+ COPY_DEVICE_TO_VMA_FUNC(vkBindImageMemory2, vkBindImageMemory2KHR)
+ }
+#endif
+#if VMA_VULKAN_VERSION >= 1003000
+ if (pAllocatorCreateInfo->vulkanApiVersion >= VK_MAKE_VERSION(1, 3, 0))
+ {
+ COPY_DEVICE_TO_VMA_FUNC(vkGetDeviceBufferMemoryRequirements, vkGetDeviceBufferMemoryRequirements)
+ COPY_DEVICE_TO_VMA_FUNC(vkGetDeviceImageMemoryRequirements, vkGetDeviceImageMemoryRequirements)
+ }
+#endif
+#if VMA_KHR_MAINTENANCE4
+ if((pAllocatorCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT) != 0)
+ {
+ COPY_DEVICE_TO_VMA_FUNC(vkGetDeviceBufferMemoryRequirementsKHR, vkGetDeviceBufferMemoryRequirements)
+ COPY_DEVICE_TO_VMA_FUNC(vkGetDeviceImageMemoryRequirementsKHR, vkGetDeviceImageMemoryRequirements)
+ }
+#endif
+#if VMA_DEDICATED_ALLOCATION
+ if ((pAllocatorCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT) != 0)
+ {
+ COPY_DEVICE_TO_VMA_FUNC(vkGetBufferMemoryRequirements2KHR, vkGetBufferMemoryRequirements2KHR)
+ COPY_DEVICE_TO_VMA_FUNC(vkGetImageMemoryRequirements2KHR, vkGetImageMemoryRequirements2KHR)
+ }
+#endif
+#if VMA_BIND_MEMORY2
+ if ((pAllocatorCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_BIND_MEMORY2_BIT) != 0)
+ {
+ COPY_DEVICE_TO_VMA_FUNC(vkBindBufferMemory2KHR, vkBindBufferMemory2KHR)
+ COPY_DEVICE_TO_VMA_FUNC(vkBindImageMemory2KHR, vkBindImageMemory2KHR)
+ }
+#endif
+#if VMA_MEMORY_BUDGET
+ if ((pAllocatorCreateInfo->flags & VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT) != 0)
+ {
+ COPY_GLOBAL_TO_VMA_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR, vkGetPhysicalDeviceMemoryProperties2KHR)
+ }
+#endif
+#if VMA_EXTERNAL_MEMORY_WIN32
+ if ((pAllocatorCreateInfo->flags & VMA_ALLOCATOR_CREATE_KHR_EXTERNAL_MEMORY_WIN32_BIT) != 0)
+ {
+ COPY_DEVICE_TO_VMA_FUNC(vkGetMemoryWin32HandleKHR, vkGetMemoryWin32HandleKHR)
+ }
+#endif
+
+#undef COPY_DEVICE_TO_VMA_FUNC
+#undef COPY_GLOBAL_TO_VMA_FUNC
+
+ return VK_SUCCESS;
+}
+
+#endif // #ifdef VOLK_HEADER_VERSION
+
VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateAllocator(
const VmaAllocatorCreateInfo* pCreateInfo,
VmaAllocator* pAllocator)
@@ -15387,7 +15540,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForBufferInfo(
const VkDevice hDev = allocator->m_hDevice;
const VmaVulkanFunctions* funcs = &allocator->GetVulkanFunctions();
- VkResult res;
+ VkResult res = VK_SUCCESS;
#if VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
if(funcs->vkGetDeviceBufferMemoryRequirements)
@@ -15439,7 +15592,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaFindMemoryTypeIndexForImageInfo(
const VkDevice hDev = allocator->m_hDevice;
const VmaVulkanFunctions* funcs = &allocator->GetVulkanFunctions();
- VkResult res;
+ VkResult res = VK_SUCCESS;
#if VMA_KHR_MAINTENANCE4 || VMA_VULKAN_VERSION >= 1003000
if(funcs->vkGetDeviceImageMemoryRequirements)
@@ -16382,6 +16535,9 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateImage(
{
VMA_ASSERT(allocator && pImageCreateInfo && pAllocationCreateInfo && pImage && pAllocation);
+ VMA_ASSERT((pImageCreateInfo->flags & VK_IMAGE_CREATE_DISJOINT_BIT_COPY) == 0 &&
+ "vmaCreateImage() doesn't support disjoint multi-planar images. Please allocate memory for the planes using vmaAllocateMemory() and bind them using vmaBindImageMemory2().");
+
if(pImageCreateInfo->extent.width == 0 ||
pImageCreateInfo->extent.height == 0 ||
pImageCreateInfo->extent.depth == 0 ||
@@ -16553,6 +16709,11 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateVirtualBlock(
VMA_DEBUG_LOG("vmaCreateVirtualBlock");
VMA_DEBUG_GLOBAL_MUTEX_LOCK;
*pVirtualBlock = vma_new(pCreateInfo->pAllocationCallbacks, VmaVirtualBlock_T)(*pCreateInfo);
+ return VK_SUCCESS;
+
+ /*
+ Code for the future if we ever need a separate Init() method that could fail:
+
VkResult res = (*pVirtualBlock)->Init();
if(res < 0)
{
@@ -16560,6 +16721,7 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaCreateVirtualBlock(
*pVirtualBlock = VK_NULL_HANDLE;
}
return res;
+ */
}
VMA_CALL_PRE void VMA_CALL_POST vmaDestroyVirtualBlock(VmaVirtualBlock VMA_NULLABLE virtualBlock)
@@ -16683,6 +16845,260 @@ VMA_CALL_PRE VkResult VMA_CALL_POST vmaGetMemoryWin32Handle(VmaAllocator VMA_NOT
#endif // VMA_IMPLEMENTATION
/**
+\page faq Frequenty asked questions
+
+What is VMA?
+
+Vulkan(R) Memory Allocator (VMA) is a software library for developers who use the Vulkan graphics API in their code.
+It is written in C++.
+
+What is the license of VMA?
+
+VMA is licensed under MIT, which means it is open source and free software.
+
+What is the purpose of VMA?
+
+VMA helps with handling one aspect of Vulkan usage, which is device memory management -
+allocation of `VkDeviceMemory` objects, and creation of `VkBuffer` and `VkImage` objects.
+
+Do I need to use VMA?
+
+You don't need to, but it may be beneficial in many cases.
+Vulkan is a complex and low-level API, so libraries like this that abstract certain aspects of the API
+and bring them to a higher level are useful.
+When developing any non-trivial Vulkan application, you likely need to use a memory allocator.
+Using VMA can save time compared to implementing your own.
+
+When should I not use VMA?
+
+While VMA is useful for most applications that use the Vulkan API, there are cases
+when it may be a better choice not to use it.
+For example, if the application is very simple, e.g. serving as a sample or a learning exercise
+to help you understand or teach others the basics of Vulkan,
+and it creates only a small number of buffers and images, then including VMA may be an overkill.
+Developing your own memory allocator may also be a good learning exercise.
+
+What are the benefits of using VMA?
+
+-# VMA helps in choosing the optimal memory type for your resource (buffer or image).
+ In Vulkan, we have a two-level hierarchy of memory heaps and types with different flags,
+ and each device can expose a different set of those.
+ Implementing logic that would select the best memory type on each platform is a non-trivial task.
+ VMA does that, expecting only a high-level description of the intended usage of your resource.
+ For more information, see \subpage choosing_memory_type.
+-# VMA allocates large blocks of `VkDeviceMemory` and sub-allocates parts of them for your resources.
+ Allocating a new block of device memory may be a time-consuming operation.
+ Some platforms also have a limit on the maximum number of those blocks (`VkPhysicalDeviceLimits::maxMemoryAllocationCount`)
+ as low as 4096, so allocating a separate one for each resource is not an option.
+ Sub-allocating parts of a memory block requires implementing an allocation algorithm,
+ which is a non-trivial task.
+ VMA does that, using an advanced and efficient algorithm that works well in various use cases.
+-# VMA offers a simple API that allows creating buffers and textures within one function call.
+ In Vulkan, the creation of a resource is a multi-step process.
+ You need to create a `VkBuffer` or `VkImage`, ask it for memory requirements,
+ allocate a `VkDeviceMemory` object, and finally bind the resource to the memory block.
+ VMA does that automatically under a simple API within one function call: vmaCreateBuffer(), vmaCreateImage().
+
+The library is doing much more under the hood.
+For example, it respects limits like `bufferImageGranularity`, `nonCoherentAtomSize`,
+and `VkMemoryDedicatedRequirements` automatically, so you don't need to think about it.
+
+Which version should I pick?
+
+You can just pick [the latest version from the "master" branch](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator).
+It is kept in a good shape most of the time, compiling and working correctly,
+with no compatibility-breaking changes and no unfinished code.
+
+If you want an even more stable version, you can pick
+[the latest official release](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/releases).
+Current code from the master branch is occasionally tagged as a release,
+with [CHANGELOG](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator/blob/master/CHANGELOG.md)
+carefully curated to enumerate all important changes since the previous version.
+
+The library uses [Semantic Versioning](https://semver.org/),
+which means versions that only differ in the patch number are forward and backward compatible
+(e.g., only fixing some bugs), while versions that differ in the minor number are backward compatible
+(e.g., only adding new functions to the API, but not removing or changing existing ones).
+
+How to integrate it with my code?
+
+VMA is an STB-style single-header C++ library.
+
+You can pull the entire GitHub repository, e.g. using Git submodules.
+The repository contains ancillary files like the Cmake script, Doxygen config file,
+sample application, test suite, and others.
+You can compile it as a library and link with your project.
+
+However, a simpler way is taking the single file "include/vk_mem_alloc.h" and including it in your project.
+This extensive file contains all you need: a copyright notice,
+declarations of the public library interface (API), its internal implementation,
+and even the documentation in form of Doxygen-style comments.
+
+The "STB style" means not everything is implemented as inline functions in the header file.
+You need to extract the internal implementation using a special macro.
+This means that in every .cpp file where you need to use the library you should
+`#include "vk_mem_alloc.h"` to include its public interface,
+but additionally in exactly one .cpp file you should `#define VMA_IMPLEMENTATION`
+before this `#include` to enable its internal implementation.
+For more information, see [Project setup](@ref quick_start_project_setup).
+
+Does the library work with C or C++?
+
+The internal implementation of VMA is written in C++.
+It is distributed in the source format, so you need a compiler supporting at least C++14 to build it.
+
+However, the public interface of the library is written in C - using only enums, structs, and global functions,
+in the same style as Vulkan, so you can use the library in the C code.
+
+I am not a fan of modern C++. Can I still use it?
+
+Very likely yes.
+We acknowledge that many C++ developers, especially in the games industry,
+do not appreciate all the latest features that the language has to offer.
+
+- VMA doesn't throw or catch any C++ exceptions.
+ It reports errors by returning a `VkResult` value instead, just like Vulkan.
+ If you don't use exceptions in your project, your code is not exception-safe,
+ or even if you disable exception handling in the compiler options, you can still use VMA.
+- VMA doesn't use C++ run-time type information like `typeid` or `dynamic_cast`,
+ so if you disable RTTI in the compiler options, you can still use the library.
+- VMA uses only a limited subset of standard C and C++ library.
+ It doesn't use STL containers like `std::vector`, `map`, or `string`,
+ either in the public interface nor in the internal implementation.
+ It implements its own containers instead.
+- If you don't use the default heap memory allocator through `malloc/free` or `new/delete`
+ but implement your own allocator instead, you can pass it to VMA and
+ the library will use your functions for every dynamic heap allocation made internally,
+ as well as passing it further to Vulkan functions. For details, see [Custom host memory allocator](@ref custom_memory_allocator).
+
+Is it available for other programming languages?
+
+VMA is a C++ library with C interface in similar style as Vulkan.
+An object-oriented C++ wrapper or bindings to other programming languages are out of scope of this project,
+but they are welcome as external projects.
+Some of them are listed in [README.md, "See also" section](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator?tab=readme-ov-file#see-also),
+including binding to C++, Python, Rust, and Haskell.
+Before using any of them, please check if they are still maintained and updated to use a recent version of VMA.
+
+What platforms does it support?
+
+VMA relies only on Vulkan and some parts of the standard C and C++ library,
+so it supports any platform where a C++ compiler and Vulkan are available.
+It is developed mostly on Microsoft(R) Windows(R),
+but it has been successfully used in Linux(R), MacOS, Android, and even FreeBSD and Raspberry Pi.
+
+Does it only work on AMD GPUs?
+
+No! While VMA is published by AMD, it works on any GPU that supports Vulkan,
+whether a discrete PC graphics card, a processor integrated graphics, or a mobile SoC.
+It doesn't give AMD GPUs any advantage over any other GPUs.
+
+What Vulkan versions and extensions are supported?
+
+VMA is updated to support the latest versions of Vulkan.
+It currently supports Vulkan up to 1.4.
+The library also supports older versions down to the first release of Vulkan 1.0.
+Defining a higher minimum version support would help simplify the code,
+but we acknowledge that developers on some platforms like Android still use older versions,
+so the support is provided for all of them.
+
+Among many extensions available for Vulkan, only a few interact with memory management.
+VMA can automatically take advantage of them. Some of them are:
+VK_EXT_memory_budget, VK_EXT_memory_priority, VK_KHR_external_memory_win32, and VK_KHR_maintenance*
+extensions that are later promoted to the new versions of the core Vulkan API.
+
+To use them, it is your responsibility to validate if they are available on the current system and if so,
+enable them while creating the Vulkan device object.
+You also need to pass appropriate #VmaAllocatorCreateFlagBits to inform VMA that they are enabled.
+Then, the library will automatically take advantage of them.
+For more information and the full list of supported extensions, see [Enabling extensions](@ref quick_start_initialization_enabling_extensions).
+
+Does it support other graphics APIs, like Microsoft DirectX(R) 12?
+
+No, but we offer an equivalent library for DirectX 12:
+[D3D12 Memory Allocator](https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator).
+It uses the same core allocation algorithm.
+It also shares many features with VMA, like the support for custom pools and virtual allocator.
+However, it is not identical in terms of the features supported.
+Its API also looks different, because while the interface of VMA is similar in style to Vulkan,
+the interface of D3D12MA is similar to DirectX 12.
+
+Is the library lightweight?
+
+It depends on how you define it.
+VMA is implemented with high-performance and real-time applications like video games in mind.
+The CPU performance overhead of using this library is low.
+It uses a high-quality allocation algorithm called Two-Level Segregated Fit (TLSF),
+which in most cases can find a free place for a new allocation in few steps.
+The library also doesn't perform too many CPU heap allocations.
+In many cases, the allocation happens with 0 new CPU heap allocations performed by the library.
+Even the creation of a #VmaAllocation object doesn't typically feature an CPU allocation,
+because these objects are returned out of a dedicated memory pool.
+
+On the other hand, however, VMA needs some extra memory and extra time
+to maintain the metadata about the occupied and free regions of the memory blocks,
+and the algorithms and data structures used must be generic enough to work well in most cases.
+If you develop your program for a very resource-constrained platform,
+a custom allocator simpler than VMA may be a better choice.
+
+Does it have a documentation?
+
+Yes! VMA comes with full documentation of all elements of the API (functions, structures, enums),
+as well as many generic chapters that provide an introduction,
+describe core concepts of the library, good practices, etc.
+The entire documentation is written in form of code comments inside "vk_mem_alloc.h", in Doxygen format.
+You can access it in multiple ways:
+
+- Browsable online: https://gpuopen-librariesandsdks.github.io/VulkanMemoryAllocator/html/
+- Local HTML pages available after you clone the repository and open file "docs/html/index.html".
+- You can rebuild the documentation in HTML or some other format from the source code using Doxygen.
+ Configuration file "Doxyfile" is part of the repository.
+- Finally, you can just read the comments preceding declarations of any public functions of the library.
+
+Is it a mature project?
+
+Yes! The library is in development since June 2017, has over 1000 commits, over 400 issue tickets
+and pull requests (most of them resolved), and over 70 contributors.
+It is distributed together with Vulkan SDK.
+It is used by many software projects, including some large and popular ones like Qt or Blender,
+as well as some AAA games.
+According to the [LunarG 2024 Ecosystem Survey](https://www.lunarg.com/2024-ecosystem-survey-progress-report-released/),
+it is used by over 50% of Vulkan developers.
+
+How can I contribute to the project?
+
+If you have an idea for improvement or a feature request,
+you can go to [the library repository](https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator)
+and create an Issue ticket, describing your idea.
+You can also implement it yourself by forking the repository, making changes to the code,
+and creating a Pull request.
+
+If you want to ask a question, you can also create a ticket the same way.
+Before doing this, please make sure you read the relevant part of the Vulkan specification and VMA documentation,
+where you may find the answers to your question.
+
+If you want to report a suspected bug, you can also create a ticket the same way.
+Before doing this, please put some effort into the investigation of whether the bug is really
+in the library and not in your code or in the Vulkan implementation (the GPU driver) on your platform:
+
+- Enable Vulkan validation layer and make sure it is free from any errors.
+- Make sure `VMA_ASSERT` is defined to an implementation that can report a failure and not ignore it.
+- Try making your allocation using pure Vulkan functions rather than VMA and see if the bug persists.
+
+I found some compilation warnings. How can we fix them?
+
+Seeing compiler warnings may be annoying to some developers,
+but it is a design decision to not fix all of them.
+Due to the nature of the C++ language, certain preprocessor macros can make some variables unused,
+function parameters unreferenced, or conditional expressions constant in some configurations.
+The code of this library should not be bigger or more complicated just to silence these warnings.
+It is recommended to disable such warnings instead.
+For more information, see [Features not supported](@ref general_considerations_features_not_supported).
+
+However, if you observe a warning that is really dangerous, e.g.,
+about an implicit conversion from a larger to a smaller integer type, please report it and it will be fixed ASAP.
+
+
\page quick_start Quick start
\section quick_start_project_setup Project setup
@@ -16778,7 +17194,7 @@ See code sample below.
\subsection quick_start_initialization_importing_vulkan_functions Importing Vulkan functions
-You may need to configure importing Vulkan functions. There are 3 ways to do this:
+You may need to configure importing Vulkan functions. There are 4 ways to do this:
-# **If you link with Vulkan static library** (e.g. "vulkan-1.lib" on Windows):
- You don't need to do anything.
@@ -16789,10 +17205,13 @@ You may need to configure importing Vulkan functions. There are 3 ways to do thi
- Provide pointers to these two functions via VmaVulkanFunctions::vkGetInstanceProcAddr,
VmaVulkanFunctions::vkGetDeviceProcAddr.
- The library will fetch pointers to all other functions it needs internally.
--# **If you fetch pointers to all Vulkan functions in a custom way**, e.g. using some loader like
- [Volk](https://github.com/zeux/volk):
+-# **If you fetch pointers to all Vulkan functions in a custom way**:
- Define `VMA_STATIC_VULKAN_FUNCTIONS` and `VMA_DYNAMIC_VULKAN_FUNCTIONS` to 0.
- Pass these pointers via structure #VmaVulkanFunctions.
+-# **If you use [volk library](https://github.com/zeux/volk)**:
+ - Define `VMA_STATIC_VULKAN_FUNCTIONS` and `VMA_DYNAMIC_VULKAN_FUNCTIONS` to 0.
+ - Use function vmaImportVulkanFunctionsFromVolk() to fill in the structure #VmaVulkanFunctions.
+ For more information, see the description of this function.
\subsection quick_start_initialization_enabling_extensions Enabling extensions
@@ -17040,7 +17459,7 @@ memory type 2, use following code:
uint32_t memoryTypeIndex = 2;
VmaAllocationCreateInfo allocInfo = {};
-allocInfo.memoryTypeBits = 1u << memoryTypeIndex;
+allocInfo.memoryTypeBits = 1U << memoryTypeIndex;
VkBuffer buffer;
VmaAllocation allocation;
@@ -17058,7 +17477,7 @@ by setting all bits of `memoryTypeBits` to 1 except the ones you choose.
uint32_t excludedMemoryTypeIndex = 2;
VmaAllocationCreateInfo allocInfo = {};
allocInfo.usage = VMA_MEMORY_USAGE_AUTO;
-allocInfo.memoryTypeBits = ~(1u << excludedMemoryTypeIndex);
+allocInfo.memoryTypeBits = ~(1U << excludedMemoryTypeIndex);
// ...
\endcode
@@ -17480,7 +17899,7 @@ VkResult res = vmaFindMemoryTypeIndexForBufferInfo(allocator,
// Create a pool that can have at most 2 blocks, 128 MiB each.
VmaPoolCreateInfo poolCreateInfo = {};
poolCreateInfo.memoryTypeIndex = memTypeIndex;
-poolCreateInfo.blockSize = 128ull * 1024 * 1024;
+poolCreateInfo.blockSize = 128ULL * 1024 * 1024;
poolCreateInfo.maxBlockCount = 2;
VmaPool pool;
@@ -17587,7 +18006,7 @@ Many of the common concerns can be addressed in a different way than using custo
- If you want to choose a custom size for the default memory block, you can set it globally instead
using VmaAllocatorCreateInfo::preferredLargeHeapBlockSize.
- If you want to select specific memory type for your allocation,
- you can set VmaAllocationCreateInfo::memoryTypeBits to `(1u << myMemoryTypeIndex)` instead.
+ you can set VmaAllocationCreateInfo::memoryTypeBits to `(1U << myMemoryTypeIndex)` instead.
- If you need to create a buffer with certain minimum alignment, you can still do it
using default pools with dedicated function vmaCreateBufferWithAlignment().
@@ -18726,7 +19145,7 @@ When using this extension, you should initialize following member:
- VmaAllocationCreateInfo::priority when creating a dedicated allocation with #VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT.
- VmaPoolCreateInfo::priority when creating a custom pool.
-It should be a floating-point value between `0.0f` and `1.0f`, where recommended default is `0.5f`.
+It should be a floating-point value between `0.0f` and `1.0f`, where recommended default is `0.5F`.
Memory allocated with higher value can be treated by the Vulkan implementation as higher priority
and so it can have lower chances of being pushed out to system memory, experiencing degraded performance.
@@ -18762,7 +19181,7 @@ vmaCreateImage(allocator, &imgCreateInfo, &allocCreateInfo, &img, &alloc, nullpt
- Allocations created in custom pools: They inherit the priority, along with all other allocation parameters
from the parameters passed in #VmaPoolCreateInfo when the pool was created.
- Allocations created in default pools: They inherit the priority from the parameters
- VMA used when creating default pools, which means `priority == 0.5f`.
+ VMA used when creating default pools, which means `priority == 0.5F`.
\page vk_amd_device_coherent_memory VK_AMD_device_coherent_memory
@@ -18812,7 +19231,7 @@ devices. There are multiple ways to do it, for example:
or VmaAllocationCreateInfo::preferredFlags. Those flags can be freely mixed with
other ways of \ref choosing_memory_type, like setting VmaAllocationCreateInfo::usage.
- If you manually found memory type index to use for this purpose, force allocation
- from this specific index by setting VmaAllocationCreateInfo::memoryTypeBits `= 1u << index`.
+ from this specific index by setting VmaAllocationCreateInfo::memoryTypeBits `= 1U << index`.
\section vk_amd_device_coherent_memory_more_information More information
diff --git a/third_party/vulkan/vulkan.cppm b/third_party/vulkan/vulkan.cppm
index 0909b2b..651e6fc 100644
--- a/third_party/vulkan/vulkan.cppm
+++ b/third_party/vulkan/vulkan.cppm
@@ -42,11 +42,16 @@ export namespace VULKAN_HPP_NAMESPACE
{
using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase;
using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic;
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
+# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+ using VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic;
+# endif
+#endif
#if !defined( VK_NO_PROTOTYPES )
using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic;
using VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic;
#endif /*VK_NO_PROTOTYPES*/
- } // namespace detail
+ } // namespace detail
using VULKAN_HPP_NAMESPACE::operator&;
using VULKAN_HPP_NAMESPACE::operator|;
@@ -753,6 +758,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV;
using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV;
+ //=== VK_QCOM_tile_shading ===
+ using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagBitsQCOM;
+ using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM;
+
#if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagBitsEXT;
@@ -849,6 +858,15 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::DirectDriverLoadingFlagsLUNARG;
using VULKAN_HPP_NAMESPACE::DirectDriverLoadingModeLUNARG;
+ //=== VK_ARM_tensors ===
+ using VULKAN_HPP_NAMESPACE::TensorCreateFlagBitsARM;
+ using VULKAN_HPP_NAMESPACE::TensorCreateFlagsARM;
+ using VULKAN_HPP_NAMESPACE::TensorTilingARM;
+ using VULKAN_HPP_NAMESPACE::TensorUsageFlagBitsARM;
+ using VULKAN_HPP_NAMESPACE::TensorUsageFlagsARM;
+ using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagBitsARM;
+ using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagsARM;
+
//=== VK_NV_optical_flow ===
using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagBitsNV;
using VULKAN_HPP_NAMESPACE::OpticalFlowExecuteFlagsNV;
@@ -889,6 +907,17 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::ScopeKHR;
using VULKAN_HPP_NAMESPACE::ScopeNV;
+ //=== VK_ARM_data_graph ===
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchFlagBitsARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchFlagsARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointTypeARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateFlagBitsARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateFlagsARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationTypeARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineTypeARM;
+
//=== VK_KHR_video_encode_av1 ===
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilityFlagBitsKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilityFlagsKHR;
@@ -953,6 +982,15 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_depth_clamp_control ===
using VULKAN_HPP_NAMESPACE::DepthClampModeEXT;
+ //=== 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 ===
//=========================
@@ -1555,6 +1593,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportSpecVersion;
+ //=== VK_KHR_shader_bfloat16 ===
+ using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16ExtensionName;
+ using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16SpecVersion;
+
//=== VK_EXT_sample_locations ===
using VULKAN_HPP_NAMESPACE::EXTSampleLocationsExtensionName;
using VULKAN_HPP_NAMESPACE::EXTSampleLocationsSpecVersion;
@@ -2088,6 +2130,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVCudaKernelLaunchSpecVersion;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ //=== VK_QCOM_tile_shading ===
+ using VULKAN_HPP_NAMESPACE::QCOMTileShadingExtensionName;
+ using VULKAN_HPP_NAMESPACE::QCOMTileShadingSpecVersion;
+
//=== VK_NV_low_latency ===
using VULKAN_HPP_NAMESPACE::NVLowLatencyExtensionName;
using VULKAN_HPP_NAMESPACE::NVLowLatencySpecVersion;
@@ -2442,6 +2488,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::LUNARGDirectDriverLoadingExtensionName;
using VULKAN_HPP_NAMESPACE::LUNARGDirectDriverLoadingSpecVersion;
+ //=== VK_ARM_tensors ===
+ using VULKAN_HPP_NAMESPACE::ARMTensorsExtensionName;
+ using VULKAN_HPP_NAMESPACE::ARMTensorsSpecVersion;
+
//=== VK_EXT_shader_module_identifier ===
using VULKAN_HPP_NAMESPACE::EXTShaderModuleIdentifierExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShaderModuleIdentifierSpecVersion;
@@ -2477,6 +2527,14 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::AMDAntiLagExtensionName;
using VULKAN_HPP_NAMESPACE::AMDAntiLagSpecVersion;
+ //=== VK_KHR_present_id2 ===
+ using VULKAN_HPP_NAMESPACE::KHRPresentId2ExtensionName;
+ using VULKAN_HPP_NAMESPACE::KHRPresentId2SpecVersion;
+
+ //=== VK_KHR_present_wait2 ===
+ using VULKAN_HPP_NAMESPACE::KHRPresentWait2ExtensionName;
+ using VULKAN_HPP_NAMESPACE::KHRPresentWait2SpecVersion;
+
//=== VK_KHR_ray_tracing_position_fetch ===
using VULKAN_HPP_NAMESPACE::KHRRayTracingPositionFetchExtensionName;
using VULKAN_HPP_NAMESPACE::KHRRayTracingPositionFetchSpecVersion;
@@ -2546,6 +2604,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::KHRCooperativeMatrixExtensionName;
using VULKAN_HPP_NAMESPACE::KHRCooperativeMatrixSpecVersion;
+ //=== VK_ARM_data_graph ===
+ using VULKAN_HPP_NAMESPACE::ARMDataGraphExtensionName;
+ using VULKAN_HPP_NAMESPACE::ARMDataGraphSpecVersion;
+ using VULKAN_HPP_NAMESPACE::MaxPhysicalDeviceDataGraphOperationSetNameSizeARM;
+
//=== VK_QCOM_multiview_per_view_render_areas ===
using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasExtensionName;
using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasSpecVersion;
@@ -2563,6 +2626,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1SpecVersion;
+ //=== VK_KHR_video_decode_vp9 ===
+ using VULKAN_HPP_NAMESPACE::KHRVideoDecodeVp9ExtensionName;
+ using VULKAN_HPP_NAMESPACE::KHRVideoDecodeVp9SpecVersion;
+ using VULKAN_HPP_NAMESPACE::MaxVideoVp9ReferencesPerFrameKHR;
+
//=== VK_KHR_video_maintenance1 ===
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1SpecVersion;
@@ -2599,6 +2667,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneExtensionName;
using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneSpecVersion;
+ //=== VK_KHR_unified_image_layouts ===
+ using VULKAN_HPP_NAMESPACE::KHRUnifiedImageLayoutsExtensionName;
+ using VULKAN_HPP_NAMESPACE::KHRUnifiedImageLayoutsSpecVersion;
+
//=== VK_KHR_shader_float_controls2 ===
using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2ExtensionName;
using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2SpecVersion;
@@ -2637,6 +2709,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;
@@ -2649,6 +2725,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName;
using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion;
+ //=== VK_NV_external_compute_queue ===
+ using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueExtensionName;
+ using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueSpecVersion;
+
//=== VK_KHR_shader_relaxed_extended_instruction ===
using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName;
using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion;
@@ -2669,6 +2749,10 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTShaderReplicatedCompositesExtensionName;
using VULKAN_HPP_NAMESPACE::EXTShaderReplicatedCompositesSpecVersion;
+ //=== VK_EXT_shader_float8 ===
+ using VULKAN_HPP_NAMESPACE::EXTShaderFloat8ExtensionName;
+ using VULKAN_HPP_NAMESPACE::EXTShaderFloat8SpecVersion;
+
//=== VK_NV_ray_tracing_validation ===
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationExtensionName;
using VULKAN_HPP_NAMESPACE::NVRayTracingValidationSpecVersion;
@@ -2698,10 +2782,20 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTDepthClampControlExtensionName;
using VULKAN_HPP_NAMESPACE::EXTDepthClampControlSpecVersion;
+ //=== VK_KHR_maintenance9 ===
+ using VULKAN_HPP_NAMESPACE::KHRMaintenance9ExtensionName;
+ using VULKAN_HPP_NAMESPACE::KHRMaintenance9SpecVersion;
+
//=== VK_KHR_video_maintenance2 ===
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;
@@ -2728,12 +2822,32 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName;
using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion;
+ //=== VK_ARM_format_pack ===
+ 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;
+
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
using VULKAN_HPP_NAMESPACE::NVPresentMeteringExtensionName;
using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ //=== VK_EXT_fragment_density_map_offset ===
+ using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetExtensionName;
+ using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetSpecVersion;
+
+ //=== VK_EXT_zero_initialize_device_memory ===
+ using VULKAN_HPP_NAMESPACE::EXTZeroInitializeDeviceMemoryExtensionName;
+ using VULKAN_HPP_NAMESPACE::EXTZeroInitializeDeviceMemorySpecVersion;
+
//========================
//=== CONSTEXPR VALUEs ===
//========================
@@ -3723,6 +3837,9 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD;
using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV;
+ //=== VK_KHR_shader_bfloat16 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR;
+
//=== VK_EXT_sample_locations ===
using VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT;
using VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT;
@@ -4074,10 +4191,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT;
- //=== VK_EXT_robustness2 ===
- using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT;
- using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT;
-
//=== VK_EXT_custom_border_color ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT;
@@ -4121,6 +4234,14 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ //=== VK_QCOM_tile_shading ===
+ using VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM;
+ using VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM;
+ using VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM;
+ using VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM;
+
//=== VK_NV_low_latency ===
using VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV;
@@ -4402,11 +4523,6 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM;
using VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM;
- //=== VK_QCOM_fragment_density_map_offset ===
- using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
- using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
- using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
-
//=== VK_NV_copy_memory_indirect ===
using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
@@ -4468,6 +4584,32 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG;
using VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG;
+ //=== VK_ARM_tensors ===
+ using VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM;
+ using VULKAN_HPP_NAMESPACE::CopyTensorInfoARM;
+ using VULKAN_HPP_NAMESPACE::DescriptorGetTensorInfoARM;
+ using VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM;
+ using VULKAN_HPP_NAMESPACE::ExternalMemoryTensorCreateInfoARM;
+ using VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM;
+ using VULKAN_HPP_NAMESPACE::FrameBoundaryTensorsARM;
+ using VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoTensorARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorFeaturesARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorPropertiesARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorFeaturesARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorPropertiesARM;
+ using VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM;
+ using VULKAN_HPP_NAMESPACE::TensorCopyARM;
+ using VULKAN_HPP_NAMESPACE::TensorCreateInfoARM;
+ using VULKAN_HPP_NAMESPACE::TensorDependencyInfoARM;
+ using VULKAN_HPP_NAMESPACE::TensorDescriptionARM;
+ using VULKAN_HPP_NAMESPACE::TensorFormatPropertiesARM;
+ using VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM;
+ using VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM;
+ using VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM;
+ using VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM;
+ using VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM;
+
//=== VK_EXT_shader_module_identifier ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
@@ -4502,6 +4644,16 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD;
+ //=== VK_KHR_present_id2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PresentId2KHR;
+ using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR;
+
+ //=== VK_KHR_present_wait2 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWait2FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR;
+ using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentWait2KHR;
+
//=== VK_KHR_ray_tracing_position_fetch ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
@@ -4591,6 +4743,30 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR;
+ //=== VK_ARM_data_graph ===
+ using VULKAN_HPP_NAMESPACE::BindDataGraphPipelineSessionMemoryInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineCreateInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineIdentifierCreateInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementsInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionMemoryRequirementsInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineShaderModuleCreateInfoARM;
+ using VULKAN_HPP_NAMESPACE::DataGraphProcessingEngineCreateInfoARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphPropertiesARM;
+
//=== VK_QCOM_multiview_per_view_render_areas ===
using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
@@ -4622,6 +4798,12 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR;
+ //=== VK_KHR_video_decode_vp9 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoDecodeVP9FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeVP9CapabilitiesKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeVP9PictureInfoKHR;
+ using VULKAN_HPP_NAMESPACE::VideoDecodeVP9ProfileInfoKHR;
+
//=== VK_KHR_video_maintenance1 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR;
using VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR;
@@ -4649,6 +4831,10 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
+ //=== VK_KHR_unified_image_layouts ===
+ using VULKAN_HPP_NAMESPACE::AttachmentFeedbackLoopInfoEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR;
+
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer ===
using VULKAN_HPP_NAMESPACE::ExternalFormatQNX;
@@ -4672,6 +4858,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;
@@ -4691,6 +4884,12 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_NV_raw_access_chains ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV;
+ //=== VK_NV_external_compute_queue ===
+ using VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV;
+ using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV;
+
//=== VK_KHR_shader_relaxed_extended_instruction ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
@@ -4710,6 +4909,9 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_shader_replicated_composites ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT;
+ //=== VK_EXT_shader_float8 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat8FeaturesEXT;
+
//=== VK_NV_ray_tracing_validation ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV;
@@ -4720,6 +4922,7 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV;
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV;
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;
+ using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGetTemplateIndicesInfoNV;
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV;
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV;
using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV;
@@ -4782,12 +4985,23 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT;
using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT;
+ //=== VK_KHR_maintenance9 ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9PropertiesKHR;
+ using VULKAN_HPP_NAMESPACE::QueueFamilyOwnershipTransferPropertiesKHR;
+
//=== VK_KHR_video_maintenance2 ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR;
using VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR;
using VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR;
+#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::HdrVividDynamicMetadataHUAWEI;
using VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI;
@@ -4814,12 +5028,38 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_vertex_attribute_robustness ===
using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
+ //=== 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::PhysicalDeviceRobustness2FeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR;
+
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV;
using VULKAN_HPP_NAMESPACE::SetPresentConfigNV;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ //=== VK_EXT_fragment_density_map_offset ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+ using VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT;
+ using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT;
+ using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
+
+ //=== VK_EXT_zero_initialize_device_memory ===
+ using VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT;
+
//===============
//=== HANDLEs ===
//===============
@@ -4916,6 +5156,10 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_opacity_micromap ===
using VULKAN_HPP_NAMESPACE::MicromapEXT;
+ //=== VK_ARM_tensors ===
+ using VULKAN_HPP_NAMESPACE::TensorARM;
+ using VULKAN_HPP_NAMESPACE::TensorViewARM;
+
//=== VK_NV_optical_flow ===
using VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV;
@@ -4925,6 +5169,12 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;
+ //=== VK_ARM_data_graph ===
+ using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM;
+
+ //=== VK_NV_external_compute_queue ===
+ using VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV;
+
//=== VK_EXT_device_generated_commands ===
using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT;
using VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT;
@@ -5022,6 +5272,10 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_opacity_micromap ===
using VULKAN_HPP_NAMESPACE::UniqueMicromapEXT;
+ //=== VK_ARM_tensors ===
+ using VULKAN_HPP_NAMESPACE::UniqueTensorARM;
+ using VULKAN_HPP_NAMESPACE::UniqueTensorViewARM;
+
//=== VK_NV_optical_flow ===
using VULKAN_HPP_NAMESPACE::UniqueOpticalFlowSessionNV;
@@ -5031,6 +5285,12 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::UniquePipelineBinaryKHR;
+ //=== VK_ARM_data_graph ===
+ using VULKAN_HPP_NAMESPACE::UniqueDataGraphPipelineSessionARM;
+
+ //=== VK_NV_external_compute_queue ===
+ using VULKAN_HPP_NAMESPACE::UniqueExternalComputeQueueNV;
+
//=== VK_EXT_device_generated_commands ===
using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutEXT;
@@ -5133,6 +5393,10 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_opacity_micromap ===
using VULKAN_HPP_NAMESPACE::SharedMicromapEXT;
+ //=== VK_ARM_tensors ===
+ using VULKAN_HPP_NAMESPACE::SharedTensorARM;
+ using VULKAN_HPP_NAMESPACE::SharedTensorViewARM;
+
//=== VK_NV_optical_flow ===
using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV;
@@ -5142,6 +5406,12 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_pipeline_binary ===
using VULKAN_HPP_NAMESPACE::SharedPipelineBinaryKHR;
+ //=== VK_ARM_data_graph ===
+ using VULKAN_HPP_NAMESPACE::SharedDataGraphPipelineSessionARM;
+
+ //=== VK_NV_external_compute_queue ===
+ using VULKAN_HPP_NAMESPACE::SharedExternalComputeQueueNV;
+
//=== VK_EXT_device_generated_commands ===
using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutEXT;
@@ -5168,7 +5438,7 @@ export namespace VULKAN_HPP_NAMESPACE
namespace detail
{
using VULKAN_HPP_NAMESPACE::detail::DynamicLoader;
- } // namespace detail
+ } // namespace detail
#endif /*VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL*/
//=====================
@@ -5184,6 +5454,11 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::componentPlaneIndex;
using VULKAN_HPP_NAMESPACE::componentsAreCompressed;
using VULKAN_HPP_NAMESPACE::compressionScheme;
+ using VULKAN_HPP_NAMESPACE::getDepthFormats;
+ using VULKAN_HPP_NAMESPACE::getDepthStencilFormats;
+ using VULKAN_HPP_NAMESPACE::getStencilFormats;
+ using VULKAN_HPP_NAMESPACE::hasDepthComponent;
+ using VULKAN_HPP_NAMESPACE::hasStencilComponent;
using VULKAN_HPP_NAMESPACE::isCompressed;
using VULKAN_HPP_NAMESPACE::packed;
using VULKAN_HPP_NAMESPACE::planeCompatibleFormat;
@@ -5326,6 +5601,10 @@ export namespace VULKAN_HPP_NAMESPACE
//=== VK_EXT_opacity_micromap ===
using VULKAN_HPP_RAII_NAMESPACE::MicromapEXT;
+ //=== VK_ARM_tensors ===
+ using VULKAN_HPP_RAII_NAMESPACE::TensorARM;
+ using VULKAN_HPP_RAII_NAMESPACE::TensorViewARM;
+
//=== VK_NV_optical_flow ===
using VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV;
@@ -5337,6 +5616,12 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR;
using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHRs;
+ //=== VK_ARM_data_graph ===
+ using VULKAN_HPP_RAII_NAMESPACE::DataGraphPipelineSessionARM;
+
+ //=== VK_NV_external_compute_queue ===
+ using VULKAN_HPP_RAII_NAMESPACE::ExternalComputeQueueNV;
+
//=== VK_EXT_device_generated_commands ===
using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutEXT;
using VULKAN_HPP_RAII_NAMESPACE::IndirectExecutionSetEXT;
@@ -5497,6 +5782,12 @@ export namespace std
template <>
struct hash;
+ //=== VK_ARM_tensors ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
//=== VK_NV_optical_flow ===
template <>
struct hash;
@@ -5509,6 +5800,14 @@ export namespace std
template <>
struct hash;
+ //=== VK_ARM_data_graph ===
+ template <>
+ struct hash;
+
+ //=== VK_NV_external_compute_queue ===
+ template <>
+ struct hash;
+
//=== VK_EXT_device_generated_commands ===
template <>
struct hash;
@@ -6771,6 +7070,10 @@ export namespace std
template <>
struct hash;
+ //=== VK_KHR_shader_bfloat16 ===
+ template <>
+ struct hash;
+
//=== VK_EXT_sample_locations ===
template <>
struct hash;
@@ -7319,12 +7622,6 @@ export namespace std
template <>
struct hash;
- //=== VK_EXT_robustness2 ===
- template <>
- struct hash;
- template <>
- struct hash;
-
//=== VK_EXT_custom_border_color ===
template <>
struct hash;
@@ -7395,6 +7692,20 @@ export namespace std
struct hash;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ //=== VK_QCOM_tile_shading ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
//=== VK_NV_low_latency ===
template <>
struct hash;
@@ -7831,14 +8142,6 @@ export namespace std
template <>
struct hash;
- //=== VK_QCOM_fragment_density_map_offset ===
- template <>
- struct hash;
- template <>
- struct hash;
- template <>
- struct hash;
-
//=== VK_NV_copy_memory_indirect ===
template <>
struct hash;
@@ -7935,6 +8238,56 @@ export namespace std
template <>
struct hash;
+ //=== VK_ARM_tensors ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
//=== VK_EXT_shader_module_identifier ===
template <>
struct hash;
@@ -7987,6 +8340,22 @@ export namespace std
template <>
struct hash;
+ //=== VK_KHR_present_id2 ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
+ //=== VK_KHR_present_wait2 ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
//=== VK_KHR_ray_tracing_position_fetch ===
template <>
struct hash;
@@ -8137,6 +8506,52 @@ export namespace std
template <>
struct hash;
+ //=== VK_ARM_data_graph ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
//=== VK_QCOM_multiview_per_view_render_areas ===
template <>
struct hash;
@@ -8189,6 +8604,16 @@ export namespace std
template <>
struct hash;
+ //=== VK_KHR_video_decode_vp9 ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
//=== VK_KHR_video_maintenance1 ===
template <>
struct hash;
@@ -8229,6 +8654,12 @@ export namespace std
template <>
struct hash;
+ //=== VK_KHR_unified_image_layouts ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
//=== VK_QNX_external_memory_screen_buffer ===
template <>
@@ -8261,6 +8692,18 @@ export namespace std
template <>
struct hash;
+ //=== VK_QCOM_tile_memory_heap ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
//=== VK_NV_display_stereo ===
template <>
struct hash;
@@ -8293,6 +8736,16 @@ export namespace std
template <>
struct hash;
+ //=== VK_NV_external_compute_queue ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
//=== VK_KHR_shader_relaxed_extended_instruction ===
template <>
struct hash;
@@ -8321,6 +8774,10 @@ export namespace std
template <>
struct hash;
+ //=== VK_EXT_shader_float8 ===
+ template <>
+ struct hash;
+
//=== VK_NV_ray_tracing_validation ===
template <>
struct hash;
@@ -8357,6 +8814,8 @@ export namespace std
template <>
struct hash;
template <>
+ struct hash;
+ template <>
struct hash;
//=== VK_NV_partitioned_acceleration_structure ===
@@ -8451,6 +8910,14 @@ export namespace std
template <>
struct hash;
+ //=== VK_KHR_maintenance9 ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
//=== VK_KHR_video_maintenance2 ===
template <>
struct hash;
@@ -8461,6 +8928,12 @@ export namespace std
template <>
struct hash;
+#if defined( VK_USE_PLATFORM_OHOS )
+ //=== VK_OHOS_surface ===
+ template <>
+ struct hash;
+#endif /*VK_USE_PLATFORM_OHOS*/
+
//=== VK_HUAWEI_hdr_vivid ===
template <>
struct hash;
@@ -8497,6 +8970,24 @@ export namespace std
template <>
struct hash;
+ //=== VK_ARM_format_pack ===
+ template <>
+ struct hash;
+
+ //=== VK_VALVE_fragment_density_map_layered ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
+ //=== VK_KHR_robustness2 ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
template <>
@@ -8505,6 +8996,20 @@ export namespace std
struct hash;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ //=== VK_EXT_fragment_density_map_offset ===
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+ template <>
+ struct hash;
+
+ //=== VK_EXT_zero_initialize_device_memory ===
+ template <>
+ struct hash;
+
//=================================================================
//=== Required exports for VULKAN_HPP_NAMESPACE::StructureChain ===
//=================================================================
@@ -8517,4 +9022,1162 @@ export namespace std
// This VkFlags type is used as part of a bitfield in some structure.
// As it can't be mimicked by vk-data types, we need to export just that!!
-export using ::VkGeometryInstanceFlagsKHR;
\ No newline at end of file
+export using ::VkGeometryInstanceFlagsKHR;
+
+//==================
+//=== PFN TYPEs ===
+//==================
+
+//=== VK_VERSION_1_0 ===
+export using ::PFN_vkCreateInstance;
+export using ::PFN_vkDestroyInstance;
+export using ::PFN_vkEnumeratePhysicalDevices;
+export using ::PFN_vkGetPhysicalDeviceFeatures;
+export using ::PFN_vkGetPhysicalDeviceFormatProperties;
+export using ::PFN_vkGetPhysicalDeviceImageFormatProperties;
+export using ::PFN_vkGetPhysicalDeviceProperties;
+export using ::PFN_vkGetPhysicalDeviceQueueFamilyProperties;
+export using ::PFN_vkGetPhysicalDeviceMemoryProperties;
+export using ::PFN_vkGetInstanceProcAddr;
+export using ::PFN_vkGetDeviceProcAddr;
+export using ::PFN_vkCreateDevice;
+export using ::PFN_vkDestroyDevice;
+export using ::PFN_vkEnumerateInstanceExtensionProperties;
+export using ::PFN_vkEnumerateDeviceExtensionProperties;
+export using ::PFN_vkEnumerateInstanceLayerProperties;
+export using ::PFN_vkEnumerateDeviceLayerProperties;
+export using ::PFN_vkGetDeviceQueue;
+export using ::PFN_vkQueueSubmit;
+export using ::PFN_vkQueueWaitIdle;
+export using ::PFN_vkDeviceWaitIdle;
+export using ::PFN_vkAllocateMemory;
+export using ::PFN_vkFreeMemory;
+export using ::PFN_vkMapMemory;
+export using ::PFN_vkUnmapMemory;
+export using ::PFN_vkFlushMappedMemoryRanges;
+export using ::PFN_vkInvalidateMappedMemoryRanges;
+export using ::PFN_vkGetDeviceMemoryCommitment;
+export using ::PFN_vkBindBufferMemory;
+export using ::PFN_vkBindImageMemory;
+export using ::PFN_vkGetBufferMemoryRequirements;
+export using ::PFN_vkGetImageMemoryRequirements;
+export using ::PFN_vkGetImageSparseMemoryRequirements;
+export using ::PFN_vkGetPhysicalDeviceSparseImageFormatProperties;
+export using ::PFN_vkQueueBindSparse;
+export using ::PFN_vkCreateFence;
+export using ::PFN_vkDestroyFence;
+export using ::PFN_vkResetFences;
+export using ::PFN_vkGetFenceStatus;
+export using ::PFN_vkWaitForFences;
+export using ::PFN_vkCreateSemaphore;
+export using ::PFN_vkDestroySemaphore;
+export using ::PFN_vkCreateEvent;
+export using ::PFN_vkDestroyEvent;
+export using ::PFN_vkGetEventStatus;
+export using ::PFN_vkSetEvent;
+export using ::PFN_vkResetEvent;
+export using ::PFN_vkCreateQueryPool;
+export using ::PFN_vkDestroyQueryPool;
+export using ::PFN_vkGetQueryPoolResults;
+export using ::PFN_vkCreateBuffer;
+export using ::PFN_vkDestroyBuffer;
+export using ::PFN_vkCreateBufferView;
+export using ::PFN_vkDestroyBufferView;
+export using ::PFN_vkCreateImage;
+export using ::PFN_vkDestroyImage;
+export using ::PFN_vkGetImageSubresourceLayout;
+export using ::PFN_vkCreateImageView;
+export using ::PFN_vkDestroyImageView;
+export using ::PFN_vkCreateShaderModule;
+export using ::PFN_vkDestroyShaderModule;
+export using ::PFN_vkCreatePipelineCache;
+export using ::PFN_vkDestroyPipelineCache;
+export using ::PFN_vkGetPipelineCacheData;
+export using ::PFN_vkMergePipelineCaches;
+export using ::PFN_vkCreateGraphicsPipelines;
+export using ::PFN_vkCreateComputePipelines;
+export using ::PFN_vkDestroyPipeline;
+export using ::PFN_vkCreatePipelineLayout;
+export using ::PFN_vkDestroyPipelineLayout;
+export using ::PFN_vkCreateSampler;
+export using ::PFN_vkDestroySampler;
+export using ::PFN_vkCreateDescriptorSetLayout;
+export using ::PFN_vkDestroyDescriptorSetLayout;
+export using ::PFN_vkCreateDescriptorPool;
+export using ::PFN_vkDestroyDescriptorPool;
+export using ::PFN_vkResetDescriptorPool;
+export using ::PFN_vkAllocateDescriptorSets;
+export using ::PFN_vkFreeDescriptorSets;
+export using ::PFN_vkUpdateDescriptorSets;
+export using ::PFN_vkCreateFramebuffer;
+export using ::PFN_vkDestroyFramebuffer;
+export using ::PFN_vkCreateRenderPass;
+export using ::PFN_vkDestroyRenderPass;
+export using ::PFN_vkGetRenderAreaGranularity;
+export using ::PFN_vkCreateCommandPool;
+export using ::PFN_vkDestroyCommandPool;
+export using ::PFN_vkResetCommandPool;
+export using ::PFN_vkAllocateCommandBuffers;
+export using ::PFN_vkFreeCommandBuffers;
+export using ::PFN_vkBeginCommandBuffer;
+export using ::PFN_vkEndCommandBuffer;
+export using ::PFN_vkResetCommandBuffer;
+export using ::PFN_vkCmdBindPipeline;
+export using ::PFN_vkCmdSetViewport;
+export using ::PFN_vkCmdSetScissor;
+export using ::PFN_vkCmdSetLineWidth;
+export using ::PFN_vkCmdSetDepthBias;
+export using ::PFN_vkCmdSetBlendConstants;
+export using ::PFN_vkCmdSetDepthBounds;
+export using ::PFN_vkCmdSetStencilCompareMask;
+export using ::PFN_vkCmdSetStencilWriteMask;
+export using ::PFN_vkCmdSetStencilReference;
+export using ::PFN_vkCmdBindDescriptorSets;
+export using ::PFN_vkCmdBindIndexBuffer;
+export using ::PFN_vkCmdBindVertexBuffers;
+export using ::PFN_vkCmdDraw;
+export using ::PFN_vkCmdDrawIndexed;
+export using ::PFN_vkCmdDrawIndirect;
+export using ::PFN_vkCmdDrawIndexedIndirect;
+export using ::PFN_vkCmdDispatch;
+export using ::PFN_vkCmdDispatchIndirect;
+export using ::PFN_vkCmdCopyBuffer;
+export using ::PFN_vkCmdCopyImage;
+export using ::PFN_vkCmdBlitImage;
+export using ::PFN_vkCmdCopyBufferToImage;
+export using ::PFN_vkCmdCopyImageToBuffer;
+export using ::PFN_vkCmdUpdateBuffer;
+export using ::PFN_vkCmdFillBuffer;
+export using ::PFN_vkCmdClearColorImage;
+export using ::PFN_vkCmdClearDepthStencilImage;
+export using ::PFN_vkCmdClearAttachments;
+export using ::PFN_vkCmdResolveImage;
+export using ::PFN_vkCmdSetEvent;
+export using ::PFN_vkCmdResetEvent;
+export using ::PFN_vkCmdWaitEvents;
+export using ::PFN_vkCmdPipelineBarrier;
+export using ::PFN_vkCmdBeginQuery;
+export using ::PFN_vkCmdEndQuery;
+export using ::PFN_vkCmdResetQueryPool;
+export using ::PFN_vkCmdWriteTimestamp;
+export using ::PFN_vkCmdCopyQueryPoolResults;
+export using ::PFN_vkCmdPushConstants;
+export using ::PFN_vkCmdBeginRenderPass;
+export using ::PFN_vkCmdNextSubpass;
+export using ::PFN_vkCmdEndRenderPass;
+export using ::PFN_vkCmdExecuteCommands;
+
+//=== VK_VERSION_1_1 ===
+export using ::PFN_vkEnumerateInstanceVersion;
+export using ::PFN_vkBindBufferMemory2;
+export using ::PFN_vkBindImageMemory2;
+export using ::PFN_vkGetDeviceGroupPeerMemoryFeatures;
+export using ::PFN_vkCmdSetDeviceMask;
+export using ::PFN_vkCmdDispatchBase;
+export using ::PFN_vkEnumeratePhysicalDeviceGroups;
+export using ::PFN_vkGetImageMemoryRequirements2;
+export using ::PFN_vkGetBufferMemoryRequirements2;
+export using ::PFN_vkGetImageSparseMemoryRequirements2;
+export using ::PFN_vkGetPhysicalDeviceFeatures2;
+export using ::PFN_vkGetPhysicalDeviceProperties2;
+export using ::PFN_vkGetPhysicalDeviceFormatProperties2;
+export using ::PFN_vkGetPhysicalDeviceImageFormatProperties2;
+export using ::PFN_vkGetPhysicalDeviceQueueFamilyProperties2;
+export using ::PFN_vkGetPhysicalDeviceMemoryProperties2;
+export using ::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2;
+export using ::PFN_vkTrimCommandPool;
+export using ::PFN_vkGetDeviceQueue2;
+export using ::PFN_vkCreateSamplerYcbcrConversion;
+export using ::PFN_vkDestroySamplerYcbcrConversion;
+export using ::PFN_vkCreateDescriptorUpdateTemplate;
+export using ::PFN_vkDestroyDescriptorUpdateTemplate;
+export using ::PFN_vkUpdateDescriptorSetWithTemplate;
+export using ::PFN_vkGetPhysicalDeviceExternalBufferProperties;
+export using ::PFN_vkGetPhysicalDeviceExternalFenceProperties;
+export using ::PFN_vkGetPhysicalDeviceExternalSemaphoreProperties;
+export using ::PFN_vkGetDescriptorSetLayoutSupport;
+
+//=== VK_VERSION_1_2 ===
+export using ::PFN_vkCmdDrawIndirectCount;
+export using ::PFN_vkCmdDrawIndexedIndirectCount;
+export using ::PFN_vkCreateRenderPass2;
+export using ::PFN_vkCmdBeginRenderPass2;
+export using ::PFN_vkCmdNextSubpass2;
+export using ::PFN_vkCmdEndRenderPass2;
+export using ::PFN_vkResetQueryPool;
+export using ::PFN_vkGetSemaphoreCounterValue;
+export using ::PFN_vkWaitSemaphores;
+export using ::PFN_vkSignalSemaphore;
+export using ::PFN_vkGetBufferDeviceAddress;
+export using ::PFN_vkGetBufferOpaqueCaptureAddress;
+export using ::PFN_vkGetDeviceMemoryOpaqueCaptureAddress;
+
+//=== VK_VERSION_1_3 ===
+export using ::PFN_vkGetPhysicalDeviceToolProperties;
+export using ::PFN_vkCreatePrivateDataSlot;
+export using ::PFN_vkDestroyPrivateDataSlot;
+export using ::PFN_vkSetPrivateData;
+export using ::PFN_vkGetPrivateData;
+export using ::PFN_vkCmdSetEvent2;
+export using ::PFN_vkCmdResetEvent2;
+export using ::PFN_vkCmdWaitEvents2;
+export using ::PFN_vkCmdPipelineBarrier2;
+export using ::PFN_vkCmdWriteTimestamp2;
+export using ::PFN_vkQueueSubmit2;
+export using ::PFN_vkCmdCopyBuffer2;
+export using ::PFN_vkCmdCopyImage2;
+export using ::PFN_vkCmdCopyBufferToImage2;
+export using ::PFN_vkCmdCopyImageToBuffer2;
+export using ::PFN_vkCmdBlitImage2;
+export using ::PFN_vkCmdResolveImage2;
+export using ::PFN_vkCmdBeginRendering;
+export using ::PFN_vkCmdEndRendering;
+export using ::PFN_vkCmdSetCullMode;
+export using ::PFN_vkCmdSetFrontFace;
+export using ::PFN_vkCmdSetPrimitiveTopology;
+export using ::PFN_vkCmdSetViewportWithCount;
+export using ::PFN_vkCmdSetScissorWithCount;
+export using ::PFN_vkCmdBindVertexBuffers2;
+export using ::PFN_vkCmdSetDepthTestEnable;
+export using ::PFN_vkCmdSetDepthWriteEnable;
+export using ::PFN_vkCmdSetDepthCompareOp;
+export using ::PFN_vkCmdSetDepthBoundsTestEnable;
+export using ::PFN_vkCmdSetStencilTestEnable;
+export using ::PFN_vkCmdSetStencilOp;
+export using ::PFN_vkCmdSetRasterizerDiscardEnable;
+export using ::PFN_vkCmdSetDepthBiasEnable;
+export using ::PFN_vkCmdSetPrimitiveRestartEnable;
+export using ::PFN_vkGetDeviceBufferMemoryRequirements;
+export using ::PFN_vkGetDeviceImageMemoryRequirements;
+export using ::PFN_vkGetDeviceImageSparseMemoryRequirements;
+
+//=== VK_VERSION_1_4 ===
+export using ::PFN_vkCmdSetLineStipple;
+export using ::PFN_vkMapMemory2;
+export using ::PFN_vkUnmapMemory2;
+export using ::PFN_vkCmdBindIndexBuffer2;
+export using ::PFN_vkGetRenderingAreaGranularity;
+export using ::PFN_vkGetDeviceImageSubresourceLayout;
+export using ::PFN_vkGetImageSubresourceLayout2;
+export using ::PFN_vkCmdPushDescriptorSet;
+export using ::PFN_vkCmdPushDescriptorSetWithTemplate;
+export using ::PFN_vkCmdSetRenderingAttachmentLocations;
+export using ::PFN_vkCmdSetRenderingInputAttachmentIndices;
+export using ::PFN_vkCmdBindDescriptorSets2;
+export using ::PFN_vkCmdPushConstants2;
+export using ::PFN_vkCmdPushDescriptorSet2;
+export using ::PFN_vkCmdPushDescriptorSetWithTemplate2;
+export using ::PFN_vkCopyMemoryToImage;
+export using ::PFN_vkCopyImageToMemory;
+export using ::PFN_vkCopyImageToImage;
+export using ::PFN_vkTransitionImageLayout;
+
+//=== VK_KHR_surface ===
+export using ::PFN_vkDestroySurfaceKHR;
+export using ::PFN_vkGetPhysicalDeviceSurfaceSupportKHR;
+export using ::PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+export using ::PFN_vkGetPhysicalDeviceSurfaceFormatsKHR;
+export using ::PFN_vkGetPhysicalDeviceSurfacePresentModesKHR;
+
+//=== VK_KHR_swapchain ===
+export using ::PFN_vkCreateSwapchainKHR;
+export using ::PFN_vkDestroySwapchainKHR;
+export using ::PFN_vkGetSwapchainImagesKHR;
+export using ::PFN_vkAcquireNextImageKHR;
+export using ::PFN_vkQueuePresentKHR;
+export using ::PFN_vkGetDeviceGroupPresentCapabilitiesKHR;
+export using ::PFN_vkGetDeviceGroupSurfacePresentModesKHR;
+export using ::PFN_vkGetPhysicalDevicePresentRectanglesKHR;
+export using ::PFN_vkAcquireNextImage2KHR;
+
+//=== VK_KHR_display ===
+export using ::PFN_vkGetPhysicalDeviceDisplayPropertiesKHR;
+export using ::PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+export using ::PFN_vkGetDisplayPlaneSupportedDisplaysKHR;
+export using ::PFN_vkGetDisplayModePropertiesKHR;
+export using ::PFN_vkCreateDisplayModeKHR;
+export using ::PFN_vkGetDisplayPlaneCapabilitiesKHR;
+export using ::PFN_vkCreateDisplayPlaneSurfaceKHR;
+
+//=== VK_KHR_display_swapchain ===
+export using ::PFN_vkCreateSharedSwapchainsKHR;
+
+#if defined( VK_USE_PLATFORM_XLIB_KHR )
+//=== VK_KHR_xlib_surface ===
+export using ::PFN_vkCreateXlibSurfaceKHR;
+export using ::PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR;
+#endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+#if defined( VK_USE_PLATFORM_XCB_KHR )
+//=== VK_KHR_xcb_surface ===
+export using ::PFN_vkCreateXcbSurfaceKHR;
+export using ::PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR;
+#endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+//=== VK_KHR_wayland_surface ===
+export using ::PFN_vkCreateWaylandSurfaceKHR;
+export using ::PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
+#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+//=== VK_KHR_android_surface ===
+export using ::PFN_vkCreateAndroidSurfaceKHR;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+//=== VK_KHR_win32_surface ===
+export using ::PFN_vkCreateWin32SurfaceKHR;
+export using ::PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+//=== VK_EXT_debug_report ===
+export using ::PFN_vkCreateDebugReportCallbackEXT;
+export using ::PFN_vkDestroyDebugReportCallbackEXT;
+export using ::PFN_vkDebugReportMessageEXT;
+
+//=== VK_EXT_debug_marker ===
+export using ::PFN_vkDebugMarkerSetObjectTagEXT;
+export using ::PFN_vkDebugMarkerSetObjectNameEXT;
+export using ::PFN_vkCmdDebugMarkerBeginEXT;
+export using ::PFN_vkCmdDebugMarkerEndEXT;
+export using ::PFN_vkCmdDebugMarkerInsertEXT;
+
+//=== VK_KHR_video_queue ===
+export using ::PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR;
+export using ::PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR;
+export using ::PFN_vkCreateVideoSessionKHR;
+export using ::PFN_vkDestroyVideoSessionKHR;
+export using ::PFN_vkGetVideoSessionMemoryRequirementsKHR;
+export using ::PFN_vkBindVideoSessionMemoryKHR;
+export using ::PFN_vkCreateVideoSessionParametersKHR;
+export using ::PFN_vkUpdateVideoSessionParametersKHR;
+export using ::PFN_vkDestroyVideoSessionParametersKHR;
+export using ::PFN_vkCmdBeginVideoCodingKHR;
+export using ::PFN_vkCmdEndVideoCodingKHR;
+export using ::PFN_vkCmdControlVideoCodingKHR;
+
+//=== VK_KHR_video_decode_queue ===
+export using ::PFN_vkCmdDecodeVideoKHR;
+
+//=== VK_EXT_transform_feedback ===
+export using ::PFN_vkCmdBindTransformFeedbackBuffersEXT;
+export using ::PFN_vkCmdBeginTransformFeedbackEXT;
+export using ::PFN_vkCmdEndTransformFeedbackEXT;
+export using ::PFN_vkCmdBeginQueryIndexedEXT;
+export using ::PFN_vkCmdEndQueryIndexedEXT;
+export using ::PFN_vkCmdDrawIndirectByteCountEXT;
+
+//=== VK_NVX_binary_import ===
+export using ::PFN_vkCreateCuModuleNVX;
+export using ::PFN_vkCreateCuFunctionNVX;
+export using ::PFN_vkDestroyCuModuleNVX;
+export using ::PFN_vkDestroyCuFunctionNVX;
+export using ::PFN_vkCmdCuLaunchKernelNVX;
+
+//=== VK_NVX_image_view_handle ===
+export using ::PFN_vkGetImageViewHandleNVX;
+export using ::PFN_vkGetImageViewHandle64NVX;
+export using ::PFN_vkGetImageViewAddressNVX;
+
+//=== VK_AMD_draw_indirect_count ===
+export using ::PFN_vkCmdDrawIndirectCountAMD;
+export using ::PFN_vkCmdDrawIndexedIndirectCountAMD;
+
+//=== VK_AMD_shader_info ===
+export using ::PFN_vkGetShaderInfoAMD;
+
+//=== VK_KHR_dynamic_rendering ===
+export using ::PFN_vkCmdBeginRenderingKHR;
+export using ::PFN_vkCmdEndRenderingKHR;
+
+#if defined( VK_USE_PLATFORM_GGP )
+//=== VK_GGP_stream_descriptor_surface ===
+export using ::PFN_vkCreateStreamDescriptorSurfaceGGP;
+#endif /*VK_USE_PLATFORM_GGP*/
+
+//=== VK_NV_external_memory_capabilities ===
+export using ::PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+//=== VK_NV_external_memory_win32 ===
+export using ::PFN_vkGetMemoryWin32HandleNV;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+//=== VK_KHR_get_physical_device_properties2 ===
+export using ::PFN_vkGetPhysicalDeviceFeatures2KHR;
+export using ::PFN_vkGetPhysicalDeviceProperties2KHR;
+export using ::PFN_vkGetPhysicalDeviceFormatProperties2KHR;
+export using ::PFN_vkGetPhysicalDeviceImageFormatProperties2KHR;
+export using ::PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+export using ::PFN_vkGetPhysicalDeviceMemoryProperties2KHR;
+export using ::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
+
+//=== VK_KHR_device_group ===
+export using ::PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR;
+export using ::PFN_vkCmdSetDeviceMaskKHR;
+export using ::PFN_vkCmdDispatchBaseKHR;
+
+#if defined( VK_USE_PLATFORM_VI_NN )
+//=== VK_NN_vi_surface ===
+export using ::PFN_vkCreateViSurfaceNN;
+#endif /*VK_USE_PLATFORM_VI_NN*/
+
+//=== VK_KHR_maintenance1 ===
+export using ::PFN_vkTrimCommandPoolKHR;
+
+//=== VK_KHR_device_group_creation ===
+export using ::PFN_vkEnumeratePhysicalDeviceGroupsKHR;
+
+//=== VK_KHR_external_memory_capabilities ===
+export using ::PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+//=== VK_KHR_external_memory_win32 ===
+export using ::PFN_vkGetMemoryWin32HandleKHR;
+export using ::PFN_vkGetMemoryWin32HandlePropertiesKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+//=== VK_KHR_external_memory_fd ===
+export using ::PFN_vkGetMemoryFdKHR;
+export using ::PFN_vkGetMemoryFdPropertiesKHR;
+
+//=== VK_KHR_external_semaphore_capabilities ===
+export using ::PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+//=== VK_KHR_external_semaphore_win32 ===
+export using ::PFN_vkImportSemaphoreWin32HandleKHR;
+export using ::PFN_vkGetSemaphoreWin32HandleKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+//=== VK_KHR_external_semaphore_fd ===
+export using ::PFN_vkImportSemaphoreFdKHR;
+export using ::PFN_vkGetSemaphoreFdKHR;
+
+//=== VK_KHR_push_descriptor ===
+export using ::PFN_vkCmdPushDescriptorSetKHR;
+export using ::PFN_vkCmdPushDescriptorSetWithTemplateKHR;
+
+//=== VK_EXT_conditional_rendering ===
+export using ::PFN_vkCmdBeginConditionalRenderingEXT;
+export using ::PFN_vkCmdEndConditionalRenderingEXT;
+
+//=== VK_KHR_descriptor_update_template ===
+export using ::PFN_vkCreateDescriptorUpdateTemplateKHR;
+export using ::PFN_vkDestroyDescriptorUpdateTemplateKHR;
+export using ::PFN_vkUpdateDescriptorSetWithTemplateKHR;
+
+//=== VK_NV_clip_space_w_scaling ===
+export using ::PFN_vkCmdSetViewportWScalingNV;
+
+//=== VK_EXT_direct_mode_display ===
+export using ::PFN_vkReleaseDisplayEXT;
+
+#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
+//=== VK_EXT_acquire_xlib_display ===
+export using ::PFN_vkAcquireXlibDisplayEXT;
+export using ::PFN_vkGetRandROutputDisplayEXT;
+#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+//=== VK_EXT_display_surface_counter ===
+export using ::PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+
+//=== VK_EXT_display_control ===
+export using ::PFN_vkDisplayPowerControlEXT;
+export using ::PFN_vkRegisterDeviceEventEXT;
+export using ::PFN_vkRegisterDisplayEventEXT;
+export using ::PFN_vkGetSwapchainCounterEXT;
+
+//=== VK_GOOGLE_display_timing ===
+export using ::PFN_vkGetRefreshCycleDurationGOOGLE;
+export using ::PFN_vkGetPastPresentationTimingGOOGLE;
+
+//=== VK_EXT_discard_rectangles ===
+export using ::PFN_vkCmdSetDiscardRectangleEXT;
+export using ::PFN_vkCmdSetDiscardRectangleEnableEXT;
+export using ::PFN_vkCmdSetDiscardRectangleModeEXT;
+
+//=== VK_EXT_hdr_metadata ===
+export using ::PFN_vkSetHdrMetadataEXT;
+
+//=== VK_KHR_create_renderpass2 ===
+export using ::PFN_vkCreateRenderPass2KHR;
+export using ::PFN_vkCmdBeginRenderPass2KHR;
+export using ::PFN_vkCmdNextSubpass2KHR;
+export using ::PFN_vkCmdEndRenderPass2KHR;
+
+//=== VK_KHR_shared_presentable_image ===
+export using ::PFN_vkGetSwapchainStatusKHR;
+
+//=== VK_KHR_external_fence_capabilities ===
+export using ::PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+//=== VK_KHR_external_fence_win32 ===
+export using ::PFN_vkImportFenceWin32HandleKHR;
+export using ::PFN_vkGetFenceWin32HandleKHR;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+//=== VK_KHR_external_fence_fd ===
+export using ::PFN_vkImportFenceFdKHR;
+export using ::PFN_vkGetFenceFdKHR;
+
+//=== VK_KHR_performance_query ===
+export using ::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
+export using ::PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
+export using ::PFN_vkAcquireProfilingLockKHR;
+export using ::PFN_vkReleaseProfilingLockKHR;
+
+//=== VK_KHR_get_surface_capabilities2 ===
+export using ::PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+export using ::PFN_vkGetPhysicalDeviceSurfaceFormats2KHR;
+
+//=== VK_KHR_get_display_properties2 ===
+export using ::PFN_vkGetPhysicalDeviceDisplayProperties2KHR;
+export using ::PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
+export using ::PFN_vkGetDisplayModeProperties2KHR;
+export using ::PFN_vkGetDisplayPlaneCapabilities2KHR;
+
+#if defined( VK_USE_PLATFORM_IOS_MVK )
+//=== VK_MVK_ios_surface ===
+export using ::PFN_vkCreateIOSSurfaceMVK;
+#endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+#if defined( VK_USE_PLATFORM_MACOS_MVK )
+//=== VK_MVK_macos_surface ===
+export using ::PFN_vkCreateMacOSSurfaceMVK;
+#endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+//=== VK_EXT_debug_utils ===
+export using ::PFN_vkSetDebugUtilsObjectNameEXT;
+export using ::PFN_vkSetDebugUtilsObjectTagEXT;
+export using ::PFN_vkQueueBeginDebugUtilsLabelEXT;
+export using ::PFN_vkQueueEndDebugUtilsLabelEXT;
+export using ::PFN_vkQueueInsertDebugUtilsLabelEXT;
+export using ::PFN_vkCmdBeginDebugUtilsLabelEXT;
+export using ::PFN_vkCmdEndDebugUtilsLabelEXT;
+export using ::PFN_vkCmdInsertDebugUtilsLabelEXT;
+export using ::PFN_vkCreateDebugUtilsMessengerEXT;
+export using ::PFN_vkDestroyDebugUtilsMessengerEXT;
+export using ::PFN_vkSubmitDebugUtilsMessageEXT;
+
+#if defined( VK_USE_PLATFORM_ANDROID_KHR )
+//=== VK_ANDROID_external_memory_android_hardware_buffer ===
+export using ::PFN_vkGetAndroidHardwareBufferPropertiesANDROID;
+export using ::PFN_vkGetMemoryAndroidHardwareBufferANDROID;
+#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+//=== VK_AMDX_shader_enqueue ===
+export using ::PFN_vkCreateExecutionGraphPipelinesAMDX;
+export using ::PFN_vkGetExecutionGraphPipelineScratchSizeAMDX;
+export using ::PFN_vkGetExecutionGraphPipelineNodeIndexAMDX;
+export using ::PFN_vkCmdInitializeGraphScratchMemoryAMDX;
+export using ::PFN_vkCmdDispatchGraphAMDX;
+export using ::PFN_vkCmdDispatchGraphIndirectAMDX;
+export using ::PFN_vkCmdDispatchGraphIndirectCountAMDX;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+//=== VK_EXT_sample_locations ===
+export using ::PFN_vkCmdSetSampleLocationsEXT;
+export using ::PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT;
+
+//=== VK_KHR_get_memory_requirements2 ===
+export using ::PFN_vkGetImageMemoryRequirements2KHR;
+export using ::PFN_vkGetBufferMemoryRequirements2KHR;
+export using ::PFN_vkGetImageSparseMemoryRequirements2KHR;
+
+//=== VK_KHR_acceleration_structure ===
+export using ::PFN_vkCreateAccelerationStructureKHR;
+export using ::PFN_vkDestroyAccelerationStructureKHR;
+export using ::PFN_vkCmdBuildAccelerationStructuresKHR;
+export using ::PFN_vkCmdBuildAccelerationStructuresIndirectKHR;
+export using ::PFN_vkBuildAccelerationStructuresKHR;
+export using ::PFN_vkCopyAccelerationStructureKHR;
+export using ::PFN_vkCopyAccelerationStructureToMemoryKHR;
+export using ::PFN_vkCopyMemoryToAccelerationStructureKHR;
+export using ::PFN_vkWriteAccelerationStructuresPropertiesKHR;
+export using ::PFN_vkCmdCopyAccelerationStructureKHR;
+export using ::PFN_vkCmdCopyAccelerationStructureToMemoryKHR;
+export using ::PFN_vkCmdCopyMemoryToAccelerationStructureKHR;
+export using ::PFN_vkGetAccelerationStructureDeviceAddressKHR;
+export using ::PFN_vkCmdWriteAccelerationStructuresPropertiesKHR;
+export using ::PFN_vkGetDeviceAccelerationStructureCompatibilityKHR;
+export using ::PFN_vkGetAccelerationStructureBuildSizesKHR;
+
+//=== VK_KHR_ray_tracing_pipeline ===
+export using ::PFN_vkCmdTraceRaysKHR;
+export using ::PFN_vkCreateRayTracingPipelinesKHR;
+export using ::PFN_vkGetRayTracingShaderGroupHandlesKHR;
+export using ::PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR;
+export using ::PFN_vkCmdTraceRaysIndirectKHR;
+export using ::PFN_vkGetRayTracingShaderGroupStackSizeKHR;
+export using ::PFN_vkCmdSetRayTracingPipelineStackSizeKHR;
+
+//=== VK_KHR_sampler_ycbcr_conversion ===
+export using ::PFN_vkCreateSamplerYcbcrConversionKHR;
+export using ::PFN_vkDestroySamplerYcbcrConversionKHR;
+
+//=== VK_KHR_bind_memory2 ===
+export using ::PFN_vkBindBufferMemory2KHR;
+export using ::PFN_vkBindImageMemory2KHR;
+
+//=== VK_EXT_image_drm_format_modifier ===
+export using ::PFN_vkGetImageDrmFormatModifierPropertiesEXT;
+
+//=== VK_EXT_validation_cache ===
+export using ::PFN_vkCreateValidationCacheEXT;
+export using ::PFN_vkDestroyValidationCacheEXT;
+export using ::PFN_vkMergeValidationCachesEXT;
+export using ::PFN_vkGetValidationCacheDataEXT;
+
+//=== VK_NV_shading_rate_image ===
+export using ::PFN_vkCmdBindShadingRateImageNV;
+export using ::PFN_vkCmdSetViewportShadingRatePaletteNV;
+export using ::PFN_vkCmdSetCoarseSampleOrderNV;
+
+//=== VK_NV_ray_tracing ===
+export using ::PFN_vkCreateAccelerationStructureNV;
+export using ::PFN_vkDestroyAccelerationStructureNV;
+export using ::PFN_vkGetAccelerationStructureMemoryRequirementsNV;
+export using ::PFN_vkBindAccelerationStructureMemoryNV;
+export using ::PFN_vkCmdBuildAccelerationStructureNV;
+export using ::PFN_vkCmdCopyAccelerationStructureNV;
+export using ::PFN_vkCmdTraceRaysNV;
+export using ::PFN_vkCreateRayTracingPipelinesNV;
+export using ::PFN_vkGetRayTracingShaderGroupHandlesNV;
+export using ::PFN_vkGetAccelerationStructureHandleNV;
+export using ::PFN_vkCmdWriteAccelerationStructuresPropertiesNV;
+export using ::PFN_vkCompileDeferredNV;
+
+//=== VK_KHR_maintenance3 ===
+export using ::PFN_vkGetDescriptorSetLayoutSupportKHR;
+
+//=== VK_KHR_draw_indirect_count ===
+export using ::PFN_vkCmdDrawIndirectCountKHR;
+export using ::PFN_vkCmdDrawIndexedIndirectCountKHR;
+
+//=== VK_EXT_external_memory_host ===
+export using ::PFN_vkGetMemoryHostPointerPropertiesEXT;
+
+//=== VK_AMD_buffer_marker ===
+export using ::PFN_vkCmdWriteBufferMarkerAMD;
+export using ::PFN_vkCmdWriteBufferMarker2AMD;
+
+//=== VK_EXT_calibrated_timestamps ===
+export using ::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
+export using ::PFN_vkGetCalibratedTimestampsEXT;
+
+//=== VK_NV_mesh_shader ===
+export using ::PFN_vkCmdDrawMeshTasksNV;
+export using ::PFN_vkCmdDrawMeshTasksIndirectNV;
+export using ::PFN_vkCmdDrawMeshTasksIndirectCountNV;
+
+//=== VK_NV_scissor_exclusive ===
+export using ::PFN_vkCmdSetExclusiveScissorEnableNV;
+export using ::PFN_vkCmdSetExclusiveScissorNV;
+
+//=== VK_NV_device_diagnostic_checkpoints ===
+export using ::PFN_vkCmdSetCheckpointNV;
+export using ::PFN_vkGetQueueCheckpointDataNV;
+export using ::PFN_vkGetQueueCheckpointData2NV;
+
+//=== VK_KHR_timeline_semaphore ===
+export using ::PFN_vkGetSemaphoreCounterValueKHR;
+export using ::PFN_vkWaitSemaphoresKHR;
+export using ::PFN_vkSignalSemaphoreKHR;
+
+//=== VK_INTEL_performance_query ===
+export using ::PFN_vkInitializePerformanceApiINTEL;
+export using ::PFN_vkUninitializePerformanceApiINTEL;
+export using ::PFN_vkCmdSetPerformanceMarkerINTEL;
+export using ::PFN_vkCmdSetPerformanceStreamMarkerINTEL;
+export using ::PFN_vkCmdSetPerformanceOverrideINTEL;
+export using ::PFN_vkAcquirePerformanceConfigurationINTEL;
+export using ::PFN_vkReleasePerformanceConfigurationINTEL;
+export using ::PFN_vkQueueSetPerformanceConfigurationINTEL;
+export using ::PFN_vkGetPerformanceParameterINTEL;
+
+//=== VK_AMD_display_native_hdr ===
+export using ::PFN_vkSetLocalDimmingAMD;
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+//=== VK_FUCHSIA_imagepipe_surface ===
+export using ::PFN_vkCreateImagePipeSurfaceFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+//=== VK_EXT_metal_surface ===
+export using ::PFN_vkCreateMetalSurfaceEXT;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+//=== VK_KHR_fragment_shading_rate ===
+export using ::PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR;
+export using ::PFN_vkCmdSetFragmentShadingRateKHR;
+
+//=== VK_KHR_dynamic_rendering_local_read ===
+export using ::PFN_vkCmdSetRenderingAttachmentLocationsKHR;
+export using ::PFN_vkCmdSetRenderingInputAttachmentIndicesKHR;
+
+//=== VK_EXT_buffer_device_address ===
+export using ::PFN_vkGetBufferDeviceAddressEXT;
+
+//=== VK_EXT_tooling_info ===
+export using ::PFN_vkGetPhysicalDeviceToolPropertiesEXT;
+
+//=== VK_KHR_present_wait ===
+export using ::PFN_vkWaitForPresentKHR;
+
+//=== VK_NV_cooperative_matrix ===
+export using ::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV;
+
+//=== VK_NV_coverage_reduction_mode ===
+export using ::PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+//=== VK_EXT_full_screen_exclusive ===
+export using ::PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT;
+export using ::PFN_vkAcquireFullScreenExclusiveModeEXT;
+export using ::PFN_vkReleaseFullScreenExclusiveModeEXT;
+export using ::PFN_vkGetDeviceGroupSurfacePresentModes2EXT;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+//=== VK_EXT_headless_surface ===
+export using ::PFN_vkCreateHeadlessSurfaceEXT;
+
+//=== VK_KHR_buffer_device_address ===
+export using ::PFN_vkGetBufferDeviceAddressKHR;
+export using ::PFN_vkGetBufferOpaqueCaptureAddressKHR;
+export using ::PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR;
+
+//=== VK_EXT_line_rasterization ===
+export using ::PFN_vkCmdSetLineStippleEXT;
+
+//=== VK_EXT_host_query_reset ===
+export using ::PFN_vkResetQueryPoolEXT;
+
+//=== VK_EXT_extended_dynamic_state ===
+export using ::PFN_vkCmdSetCullModeEXT;
+export using ::PFN_vkCmdSetFrontFaceEXT;
+export using ::PFN_vkCmdSetPrimitiveTopologyEXT;
+export using ::PFN_vkCmdSetViewportWithCountEXT;
+export using ::PFN_vkCmdSetScissorWithCountEXT;
+export using ::PFN_vkCmdBindVertexBuffers2EXT;
+export using ::PFN_vkCmdSetDepthTestEnableEXT;
+export using ::PFN_vkCmdSetDepthWriteEnableEXT;
+export using ::PFN_vkCmdSetDepthCompareOpEXT;
+export using ::PFN_vkCmdSetDepthBoundsTestEnableEXT;
+export using ::PFN_vkCmdSetStencilTestEnableEXT;
+export using ::PFN_vkCmdSetStencilOpEXT;
+
+//=== VK_KHR_deferred_host_operations ===
+export using ::PFN_vkCreateDeferredOperationKHR;
+export using ::PFN_vkDestroyDeferredOperationKHR;
+export using ::PFN_vkGetDeferredOperationMaxConcurrencyKHR;
+export using ::PFN_vkGetDeferredOperationResultKHR;
+export using ::PFN_vkDeferredOperationJoinKHR;
+
+//=== VK_KHR_pipeline_executable_properties ===
+export using ::PFN_vkGetPipelineExecutablePropertiesKHR;
+export using ::PFN_vkGetPipelineExecutableStatisticsKHR;
+export using ::PFN_vkGetPipelineExecutableInternalRepresentationsKHR;
+
+//=== VK_EXT_host_image_copy ===
+export using ::PFN_vkCopyMemoryToImageEXT;
+export using ::PFN_vkCopyImageToMemoryEXT;
+export using ::PFN_vkCopyImageToImageEXT;
+export using ::PFN_vkTransitionImageLayoutEXT;
+export using ::PFN_vkGetImageSubresourceLayout2EXT;
+
+//=== VK_KHR_map_memory2 ===
+export using ::PFN_vkMapMemory2KHR;
+export using ::PFN_vkUnmapMemory2KHR;
+
+//=== VK_EXT_swapchain_maintenance1 ===
+export using ::PFN_vkReleaseSwapchainImagesEXT;
+
+//=== VK_NV_device_generated_commands ===
+export using ::PFN_vkGetGeneratedCommandsMemoryRequirementsNV;
+export using ::PFN_vkCmdPreprocessGeneratedCommandsNV;
+export using ::PFN_vkCmdExecuteGeneratedCommandsNV;
+export using ::PFN_vkCmdBindPipelineShaderGroupNV;
+export using ::PFN_vkCreateIndirectCommandsLayoutNV;
+export using ::PFN_vkDestroyIndirectCommandsLayoutNV;
+
+//=== VK_EXT_depth_bias_control ===
+export using ::PFN_vkCmdSetDepthBias2EXT;
+
+//=== VK_EXT_acquire_drm_display ===
+export using ::PFN_vkAcquireDrmDisplayEXT;
+export using ::PFN_vkGetDrmDisplayEXT;
+
+//=== VK_EXT_private_data ===
+export using ::PFN_vkCreatePrivateDataSlotEXT;
+export using ::PFN_vkDestroyPrivateDataSlotEXT;
+export using ::PFN_vkSetPrivateDataEXT;
+export using ::PFN_vkGetPrivateDataEXT;
+
+//=== VK_KHR_video_encode_queue ===
+export using ::PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR;
+export using ::PFN_vkGetEncodedVideoSessionParametersKHR;
+export using ::PFN_vkCmdEncodeVideoKHR;
+
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+//=== VK_NV_cuda_kernel_launch ===
+export using ::PFN_vkCreateCudaModuleNV;
+export using ::PFN_vkGetCudaModuleCacheNV;
+export using ::PFN_vkCreateCudaFunctionNV;
+export using ::PFN_vkDestroyCudaModuleNV;
+export using ::PFN_vkDestroyCudaFunctionNV;
+export using ::PFN_vkCmdCudaLaunchKernelNV;
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+//=== VK_QCOM_tile_shading ===
+export using ::PFN_vkCmdDispatchTileQCOM;
+export using ::PFN_vkCmdBeginPerTileExecutionQCOM;
+export using ::PFN_vkCmdEndPerTileExecutionQCOM;
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+//=== VK_EXT_metal_objects ===
+export using ::PFN_vkExportMetalObjectsEXT;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+//=== VK_KHR_synchronization2 ===
+export using ::PFN_vkCmdSetEvent2KHR;
+export using ::PFN_vkCmdResetEvent2KHR;
+export using ::PFN_vkCmdWaitEvents2KHR;
+export using ::PFN_vkCmdPipelineBarrier2KHR;
+export using ::PFN_vkCmdWriteTimestamp2KHR;
+export using ::PFN_vkQueueSubmit2KHR;
+
+//=== VK_EXT_descriptor_buffer ===
+export using ::PFN_vkGetDescriptorSetLayoutSizeEXT;
+export using ::PFN_vkGetDescriptorSetLayoutBindingOffsetEXT;
+export using ::PFN_vkGetDescriptorEXT;
+export using ::PFN_vkCmdBindDescriptorBuffersEXT;
+export using ::PFN_vkCmdSetDescriptorBufferOffsetsEXT;
+export using ::PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT;
+export using ::PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT;
+export using ::PFN_vkGetImageOpaqueCaptureDescriptorDataEXT;
+export using ::PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT;
+export using ::PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT;
+export using ::PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT;
+
+//=== VK_NV_fragment_shading_rate_enums ===
+export using ::PFN_vkCmdSetFragmentShadingRateEnumNV;
+
+//=== VK_EXT_mesh_shader ===
+export using ::PFN_vkCmdDrawMeshTasksEXT;
+export using ::PFN_vkCmdDrawMeshTasksIndirectEXT;
+export using ::PFN_vkCmdDrawMeshTasksIndirectCountEXT;
+
+//=== VK_KHR_copy_commands2 ===
+export using ::PFN_vkCmdCopyBuffer2KHR;
+export using ::PFN_vkCmdCopyImage2KHR;
+export using ::PFN_vkCmdCopyBufferToImage2KHR;
+export using ::PFN_vkCmdCopyImageToBuffer2KHR;
+export using ::PFN_vkCmdBlitImage2KHR;
+export using ::PFN_vkCmdResolveImage2KHR;
+
+//=== VK_EXT_device_fault ===
+export using ::PFN_vkGetDeviceFaultInfoEXT;
+
+#if defined( VK_USE_PLATFORM_WIN32_KHR )
+//=== VK_NV_acquire_winrt_display ===
+export using ::PFN_vkAcquireWinrtDisplayNV;
+export using ::PFN_vkGetWinrtDisplayNV;
+#endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+//=== VK_EXT_directfb_surface ===
+export using ::PFN_vkCreateDirectFBSurfaceEXT;
+export using ::PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT;
+#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+//=== VK_EXT_vertex_input_dynamic_state ===
+export using ::PFN_vkCmdSetVertexInputEXT;
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+//=== VK_FUCHSIA_external_memory ===
+export using ::PFN_vkGetMemoryZirconHandleFUCHSIA;
+export using ::PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+//=== VK_FUCHSIA_external_semaphore ===
+export using ::PFN_vkImportSemaphoreZirconHandleFUCHSIA;
+export using ::PFN_vkGetSemaphoreZirconHandleFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+#if defined( VK_USE_PLATFORM_FUCHSIA )
+//=== VK_FUCHSIA_buffer_collection ===
+export using ::PFN_vkCreateBufferCollectionFUCHSIA;
+export using ::PFN_vkSetBufferCollectionImageConstraintsFUCHSIA;
+export using ::PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA;
+export using ::PFN_vkDestroyBufferCollectionFUCHSIA;
+export using ::PFN_vkGetBufferCollectionPropertiesFUCHSIA;
+#endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+//=== VK_HUAWEI_subpass_shading ===
+export using ::PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI;
+export using ::PFN_vkCmdSubpassShadingHUAWEI;
+
+//=== VK_HUAWEI_invocation_mask ===
+export using ::PFN_vkCmdBindInvocationMaskHUAWEI;
+
+//=== VK_NV_external_memory_rdma ===
+export using ::PFN_vkGetMemoryRemoteAddressNV;
+
+//=== VK_EXT_pipeline_properties ===
+export using ::PFN_vkGetPipelinePropertiesEXT;
+
+//=== VK_EXT_extended_dynamic_state2 ===
+export using ::PFN_vkCmdSetPatchControlPointsEXT;
+export using ::PFN_vkCmdSetRasterizerDiscardEnableEXT;
+export using ::PFN_vkCmdSetDepthBiasEnableEXT;
+export using ::PFN_vkCmdSetLogicOpEXT;
+export using ::PFN_vkCmdSetPrimitiveRestartEnableEXT;
+
+#if defined( VK_USE_PLATFORM_SCREEN_QNX )
+//=== VK_QNX_screen_surface ===
+export using ::PFN_vkCreateScreenSurfaceQNX;
+export using ::PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX;
+#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+//=== VK_EXT_color_write_enable ===
+export using ::PFN_vkCmdSetColorWriteEnableEXT;
+
+//=== VK_KHR_ray_tracing_maintenance1 ===
+export using ::PFN_vkCmdTraceRaysIndirect2KHR;
+
+//=== VK_EXT_multi_draw ===
+export using ::PFN_vkCmdDrawMultiEXT;
+export using ::PFN_vkCmdDrawMultiIndexedEXT;
+
+//=== VK_EXT_opacity_micromap ===
+export using ::PFN_vkCreateMicromapEXT;
+export using ::PFN_vkDestroyMicromapEXT;
+export using ::PFN_vkCmdBuildMicromapsEXT;
+export using ::PFN_vkBuildMicromapsEXT;
+export using ::PFN_vkCopyMicromapEXT;
+export using ::PFN_vkCopyMicromapToMemoryEXT;
+export using ::PFN_vkCopyMemoryToMicromapEXT;
+export using ::PFN_vkWriteMicromapsPropertiesEXT;
+export using ::PFN_vkCmdCopyMicromapEXT;
+export using ::PFN_vkCmdCopyMicromapToMemoryEXT;
+export using ::PFN_vkCmdCopyMemoryToMicromapEXT;
+export using ::PFN_vkCmdWriteMicromapsPropertiesEXT;
+export using ::PFN_vkGetDeviceMicromapCompatibilityEXT;
+export using ::PFN_vkGetMicromapBuildSizesEXT;
+
+//=== VK_HUAWEI_cluster_culling_shader ===
+export using ::PFN_vkCmdDrawClusterHUAWEI;
+export using ::PFN_vkCmdDrawClusterIndirectHUAWEI;
+
+//=== VK_EXT_pageable_device_local_memory ===
+export using ::PFN_vkSetDeviceMemoryPriorityEXT;
+
+//=== VK_KHR_maintenance4 ===
+export using ::PFN_vkGetDeviceBufferMemoryRequirementsKHR;
+export using ::PFN_vkGetDeviceImageMemoryRequirementsKHR;
+export using ::PFN_vkGetDeviceImageSparseMemoryRequirementsKHR;
+
+//=== VK_VALVE_descriptor_set_host_mapping ===
+export using ::PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE;
+export using ::PFN_vkGetDescriptorSetHostMappingVALVE;
+
+//=== VK_NV_copy_memory_indirect ===
+export using ::PFN_vkCmdCopyMemoryIndirectNV;
+export using ::PFN_vkCmdCopyMemoryToImageIndirectNV;
+
+//=== VK_NV_memory_decompression ===
+export using ::PFN_vkCmdDecompressMemoryNV;
+export using ::PFN_vkCmdDecompressMemoryIndirectCountNV;
+
+//=== VK_NV_device_generated_commands_compute ===
+export using ::PFN_vkGetPipelineIndirectMemoryRequirementsNV;
+export using ::PFN_vkCmdUpdatePipelineIndirectBufferNV;
+export using ::PFN_vkGetPipelineIndirectDeviceAddressNV;
+
+//=== VK_EXT_extended_dynamic_state3 ===
+export using ::PFN_vkCmdSetDepthClampEnableEXT;
+export using ::PFN_vkCmdSetPolygonModeEXT;
+export using ::PFN_vkCmdSetRasterizationSamplesEXT;
+export using ::PFN_vkCmdSetSampleMaskEXT;
+export using ::PFN_vkCmdSetAlphaToCoverageEnableEXT;
+export using ::PFN_vkCmdSetAlphaToOneEnableEXT;
+export using ::PFN_vkCmdSetLogicOpEnableEXT;
+export using ::PFN_vkCmdSetColorBlendEnableEXT;
+export using ::PFN_vkCmdSetColorBlendEquationEXT;
+export using ::PFN_vkCmdSetColorWriteMaskEXT;
+export using ::PFN_vkCmdSetTessellationDomainOriginEXT;
+export using ::PFN_vkCmdSetRasterizationStreamEXT;
+export using ::PFN_vkCmdSetConservativeRasterizationModeEXT;
+export using ::PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT;
+export using ::PFN_vkCmdSetDepthClipEnableEXT;
+export using ::PFN_vkCmdSetSampleLocationsEnableEXT;
+export using ::PFN_vkCmdSetColorBlendAdvancedEXT;
+export using ::PFN_vkCmdSetProvokingVertexModeEXT;
+export using ::PFN_vkCmdSetLineRasterizationModeEXT;
+export using ::PFN_vkCmdSetLineStippleEnableEXT;
+export using ::PFN_vkCmdSetDepthClipNegativeOneToOneEXT;
+export using ::PFN_vkCmdSetViewportWScalingEnableNV;
+export using ::PFN_vkCmdSetViewportSwizzleNV;
+export using ::PFN_vkCmdSetCoverageToColorEnableNV;
+export using ::PFN_vkCmdSetCoverageToColorLocationNV;
+export using ::PFN_vkCmdSetCoverageModulationModeNV;
+export using ::PFN_vkCmdSetCoverageModulationTableEnableNV;
+export using ::PFN_vkCmdSetCoverageModulationTableNV;
+export using ::PFN_vkCmdSetShadingRateImageEnableNV;
+export using ::PFN_vkCmdSetRepresentativeFragmentTestEnableNV;
+export using ::PFN_vkCmdSetCoverageReductionModeNV;
+
+//=== VK_ARM_tensors ===
+export using ::PFN_vkCreateTensorARM;
+export using ::PFN_vkDestroyTensorARM;
+export using ::PFN_vkCreateTensorViewARM;
+export using ::PFN_vkDestroyTensorViewARM;
+export using ::PFN_vkGetTensorMemoryRequirementsARM;
+export using ::PFN_vkBindTensorMemoryARM;
+export using ::PFN_vkGetDeviceTensorMemoryRequirementsARM;
+export using ::PFN_vkCmdCopyTensorARM;
+export using ::PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM;
+export using ::PFN_vkGetTensorOpaqueCaptureDescriptorDataARM;
+export using ::PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM;
+
+//=== VK_EXT_shader_module_identifier ===
+export using ::PFN_vkGetShaderModuleIdentifierEXT;
+export using ::PFN_vkGetShaderModuleCreateInfoIdentifierEXT;
+
+//=== VK_NV_optical_flow ===
+export using ::PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV;
+export using ::PFN_vkCreateOpticalFlowSessionNV;
+export using ::PFN_vkDestroyOpticalFlowSessionNV;
+export using ::PFN_vkBindOpticalFlowSessionImageNV;
+export using ::PFN_vkCmdOpticalFlowExecuteNV;
+
+//=== VK_KHR_maintenance5 ===
+export using ::PFN_vkCmdBindIndexBuffer2KHR;
+export using ::PFN_vkGetRenderingAreaGranularityKHR;
+export using ::PFN_vkGetDeviceImageSubresourceLayoutKHR;
+export using ::PFN_vkGetImageSubresourceLayout2KHR;
+
+//=== VK_AMD_anti_lag ===
+export using ::PFN_vkAntiLagUpdateAMD;
+
+//=== VK_KHR_present_wait2 ===
+export using ::PFN_vkWaitForPresent2KHR;
+
+//=== VK_EXT_shader_object ===
+export using ::PFN_vkCreateShadersEXT;
+export using ::PFN_vkDestroyShaderEXT;
+export using ::PFN_vkGetShaderBinaryDataEXT;
+export using ::PFN_vkCmdBindShadersEXT;
+export using ::PFN_vkCmdSetDepthClampRangeEXT;
+
+//=== VK_KHR_pipeline_binary ===
+export using ::PFN_vkCreatePipelineBinariesKHR;
+export using ::PFN_vkDestroyPipelineBinaryKHR;
+export using ::PFN_vkGetPipelineKeyKHR;
+export using ::PFN_vkGetPipelineBinaryDataKHR;
+export using ::PFN_vkReleaseCapturedPipelineDataKHR;
+
+//=== VK_QCOM_tile_properties ===
+export using ::PFN_vkGetFramebufferTilePropertiesQCOM;
+export using ::PFN_vkGetDynamicRenderingTilePropertiesQCOM;
+
+//=== VK_NV_cooperative_vector ===
+export using ::PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV;
+export using ::PFN_vkConvertCooperativeVectorMatrixNV;
+export using ::PFN_vkCmdConvertCooperativeVectorMatrixNV;
+
+//=== VK_NV_low_latency2 ===
+export using ::PFN_vkSetLatencySleepModeNV;
+export using ::PFN_vkLatencySleepNV;
+export using ::PFN_vkSetLatencyMarkerNV;
+export using ::PFN_vkGetLatencyTimingsNV;
+export using ::PFN_vkQueueNotifyOutOfBandNV;
+
+//=== VK_KHR_cooperative_matrix ===
+export using ::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR;
+
+//=== VK_ARM_data_graph ===
+export using ::PFN_vkCreateDataGraphPipelinesARM;
+export using ::PFN_vkCreateDataGraphPipelineSessionARM;
+export using ::PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM;
+export using ::PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM;
+export using ::PFN_vkBindDataGraphPipelineSessionMemoryARM;
+export using ::PFN_vkDestroyDataGraphPipelineSessionARM;
+export using ::PFN_vkCmdDispatchDataGraphARM;
+export using ::PFN_vkGetDataGraphPipelineAvailablePropertiesARM;
+export using ::PFN_vkGetDataGraphPipelinePropertiesARM;
+export using ::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM;
+export using ::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM;
+
+//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
+export using ::PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT;
+
+#if defined( VK_USE_PLATFORM_SCREEN_QNX )
+//=== VK_QNX_external_memory_screen_buffer ===
+export using ::PFN_vkGetScreenBufferPropertiesQNX;
+#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+//=== VK_KHR_line_rasterization ===
+export using ::PFN_vkCmdSetLineStippleKHR;
+
+//=== VK_KHR_calibrated_timestamps ===
+export using ::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR;
+export using ::PFN_vkGetCalibratedTimestampsKHR;
+
+//=== VK_KHR_maintenance6 ===
+export using ::PFN_vkCmdBindDescriptorSets2KHR;
+export using ::PFN_vkCmdPushConstants2KHR;
+export using ::PFN_vkCmdPushDescriptorSet2KHR;
+export using ::PFN_vkCmdPushDescriptorSetWithTemplate2KHR;
+export using ::PFN_vkCmdSetDescriptorBufferOffsets2EXT;
+export using ::PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT;
+
+//=== VK_QCOM_tile_memory_heap ===
+export using ::PFN_vkCmdBindTileMemoryQCOM;
+
+//=== VK_NV_external_compute_queue ===
+export using ::PFN_vkCreateExternalComputeQueueNV;
+export using ::PFN_vkDestroyExternalComputeQueueNV;
+export using ::PFN_vkGetExternalComputeQueueDataNV;
+
+//=== VK_NV_cluster_acceleration_structure ===
+export using ::PFN_vkGetClusterAccelerationStructureBuildSizesNV;
+export using ::PFN_vkCmdBuildClusterAccelerationStructureIndirectNV;
+
+//=== VK_NV_partitioned_acceleration_structure ===
+export using ::PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV;
+export using ::PFN_vkCmdBuildPartitionedAccelerationStructuresNV;
+
+//=== VK_EXT_device_generated_commands ===
+export using ::PFN_vkGetGeneratedCommandsMemoryRequirementsEXT;
+export using ::PFN_vkCmdPreprocessGeneratedCommandsEXT;
+export using ::PFN_vkCmdExecuteGeneratedCommandsEXT;
+export using ::PFN_vkCreateIndirectCommandsLayoutEXT;
+export using ::PFN_vkDestroyIndirectCommandsLayoutEXT;
+export using ::PFN_vkCreateIndirectExecutionSetEXT;
+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;
+
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+//=== VK_EXT_external_memory_metal ===
+export using ::PFN_vkGetMemoryMetalHandleEXT;
+export using ::PFN_vkGetMemoryMetalHandlePropertiesEXT;
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+//=== VK_EXT_fragment_density_map_offset ===
+export using ::PFN_vkCmdEndRendering2EXT;
diff --git a/third_party/vulkan/vulkan.h b/third_party/vulkan/vulkan.h
index 9060581..9457a52 100644
--- a/third_party/vulkan/vulkan.h
+++ b/third_party/vulkan/vulkan.h
@@ -96,4 +96,8 @@
#include "vulkan_beta.h"
#endif
+#ifdef VK_USE_PLATFORM_OHOS
+#include "vulkan_ohos.h"
+#endif
+
#endif // VULKAN_H_
diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp
index d8164d8..4a62863 100644
--- a/third_party/vulkan/vulkan.hpp
+++ b/third_party/vulkan/vulkan.hpp
@@ -11,41 +11,42 @@
#include
#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
+# include
# include
import VULKAN_HPP_STD_MODULE;
#else
# include
-# include // ArrayWrapperND
+# include // ArrayWrapperND
+# include
# include // strnlen
# include // std::string
# include // std::exchange
+# if 17 <= VULKAN_HPP_CPP_VERSION
+# include
+# endif
+# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+# include // std::tie
+# include // std::vector
+# endif
+# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+# include
+# endif
+# if !defined( VULKAN_HPP_NO_EXCEPTIONS )
+# include // std::is_error_code_enum
+# endif
+# if defined( VULKAN_HPP_SUPPORT_SPAN )
+# include
+# endif
#endif
#include
-#if 17 <= VULKAN_HPP_CPP_VERSION && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
-# include
-#endif
-
-#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
-# include // std::tie
-# include // std::vector
-#endif
-
-#if !defined( VULKAN_HPP_NO_EXCEPTIONS ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
-# include // std::is_error_code_enum
-#endif
-
-#if ( VULKAN_HPP_ASSERT == assert )
-# include
-#endif
-
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
# include
# elif defined( _WIN32 ) && !defined( VULKAN_HPP_NO_WIN32_PROTOTYPES )
using HINSTANCE = struct HINSTANCE__ *;
# if defined( _WIN64 )
-using FARPROC = int64_t( __stdcall * )();
+using FARPROC = int64_t( __stdcall * )();
# else
using FARPROC = int( __stdcall * )();
# endif
@@ -55,15 +56,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
-#endif
-
-#if defined( VULKAN_HPP_SUPPORT_SPAN ) && !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
-# include
-#endif
-
-static_assert( VK_HEADER_VERSION == 310, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 319, "Wrong VK_HEADER_VERSION!" );
// includes through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
@@ -4951,6 +4944,23 @@ namespace VULKAN_HPP_NAMESPACE
}
# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ //=== VK_QCOM_tile_shading ===
+
+ void vkCmdDispatchTileQCOM( VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM * pDispatchTileInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDispatchTileQCOM( commandBuffer, pDispatchTileInfo );
+ }
+
+ void vkCmdBeginPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM * pPerTileBeginInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginPerTileExecutionQCOM( commandBuffer, pPerTileBeginInfo );
+ }
+
+ void vkCmdEndPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM * pPerTileEndInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndPerTileExecutionQCOM( commandBuffer, pPerTileEndInfo );
+ }
+
# if defined( VK_USE_PLATFORM_METAL_EXT )
//=== VK_EXT_metal_objects ===
@@ -5779,6 +5789,78 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkCmdSetCoverageReductionModeNV( commandBuffer, coverageReductionMode );
}
+ //=== VK_ARM_tensors ===
+
+ VkResult vkCreateTensorARM( VkDevice device,
+ const VkTensorCreateInfoARM * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkTensorARM * pTensor ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateTensorARM( device, pCreateInfo, pAllocator, pTensor );
+ }
+
+ void vkDestroyTensorARM( VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyTensorARM( device, tensor, pAllocator );
+ }
+
+ VkResult vkCreateTensorViewARM( VkDevice device,
+ const VkTensorViewCreateInfoARM * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkTensorViewARM * pView ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateTensorViewARM( device, pCreateInfo, pAllocator, pView );
+ }
+
+ void vkDestroyTensorViewARM( VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyTensorViewARM( device, tensorView, pAllocator );
+ }
+
+ void vkGetTensorMemoryRequirementsARM( VkDevice device,
+ const VkTensorMemoryRequirementsInfoARM * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetTensorMemoryRequirementsARM( device, pInfo, pMemoryRequirements );
+ }
+
+ VkResult vkBindTensorMemoryARM( VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindTensorMemoryARM( device, bindInfoCount, pBindInfos );
+ }
+
+ void vkGetDeviceTensorMemoryRequirementsARM( VkDevice device,
+ const VkDeviceTensorMemoryRequirementsARM * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceTensorMemoryRequirementsARM( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkCmdCopyTensorARM( VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM * pCopyTensorInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyTensorARM( commandBuffer, pCopyTensorInfo );
+ }
+
+ void vkGetPhysicalDeviceExternalTensorPropertiesARM( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo,
+ VkExternalTensorPropertiesARM * pExternalTensorProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceExternalTensorPropertiesARM( physicalDevice, pExternalTensorInfo, pExternalTensorProperties );
+ }
+
+ VkResult
+ vkGetTensorOpaqueCaptureDescriptorDataARM( VkDevice device, const VkTensorCaptureDescriptorDataInfoARM * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetTensorOpaqueCaptureDescriptorDataARM( device, pInfo, pData );
+ }
+
+ VkResult vkGetTensorViewOpaqueCaptureDescriptorDataARM( VkDevice device,
+ const VkTensorViewCaptureDescriptorDataInfoARM * pInfo,
+ void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetTensorViewOpaqueCaptureDescriptorDataARM( device, pInfo, pData );
+ }
+
//=== VK_EXT_shader_module_identifier ===
void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
@@ -5868,6 +5950,13 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkAntiLagUpdateAMD( device, pData );
}
+ //=== VK_KHR_present_wait2 ===
+
+ VkResult vkWaitForPresent2KHR( VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR * pPresentWait2Info ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkWaitForPresent2KHR( device, swapchain, pPresentWait2Info );
+ }
+
//=== VK_EXT_shader_object ===
VkResult vkCreateShadersEXT( VkDevice device,
@@ -6016,6 +6105,99 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
}
+ //=== VK_ARM_data_graph ===
+
+ VkResult vkCreateDataGraphPipelinesARM( VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkDataGraphPipelineCreateInfoARM * pCreateInfos,
+ const VkAllocationCallbacks * pAllocator,
+ VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDataGraphPipelinesARM( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+ }
+
+ VkResult vkCreateDataGraphPipelineSessionARM( VkDevice device,
+ const VkDataGraphPipelineSessionCreateInfoARM * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDataGraphPipelineSessionARM * pSession ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDataGraphPipelineSessionARM( device, pCreateInfo, pAllocator, pSession );
+ }
+
+ VkResult vkGetDataGraphPipelineSessionBindPointRequirementsARM( VkDevice device,
+ const VkDataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo,
+ uint32_t * pBindPointRequirementCount,
+ VkDataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDataGraphPipelineSessionBindPointRequirementsARM( device, pInfo, pBindPointRequirementCount, pBindPointRequirements );
+ }
+
+ void vkGetDataGraphPipelineSessionMemoryRequirementsARM( VkDevice device,
+ const VkDataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDataGraphPipelineSessionMemoryRequirementsARM( device, pInfo, pMemoryRequirements );
+ }
+
+ VkResult vkBindDataGraphPipelineSessionMemoryARM( VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindDataGraphPipelineSessionMemoryInfoARM * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindDataGraphPipelineSessionMemoryARM( device, bindInfoCount, pBindInfos );
+ }
+
+ void vkDestroyDataGraphPipelineSessionARM( VkDevice device,
+ VkDataGraphPipelineSessionARM session,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyDataGraphPipelineSessionARM( device, session, pAllocator );
+ }
+
+ void vkCmdDispatchDataGraphARM( VkCommandBuffer commandBuffer,
+ VkDataGraphPipelineSessionARM session,
+ const VkDataGraphPipelineDispatchInfoARM * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDispatchDataGraphARM( commandBuffer, session, pInfo );
+ }
+
+ VkResult vkGetDataGraphPipelineAvailablePropertiesARM( VkDevice device,
+ const VkDataGraphPipelineInfoARM * pPipelineInfo,
+ uint32_t * pPropertiesCount,
+ VkDataGraphPipelinePropertyARM * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDataGraphPipelineAvailablePropertiesARM( device, pPipelineInfo, pPropertiesCount, pProperties );
+ }
+
+ VkResult vkGetDataGraphPipelinePropertiesARM( VkDevice device,
+ const VkDataGraphPipelineInfoARM * pPipelineInfo,
+ uint32_t propertiesCount,
+ VkDataGraphPipelinePropertyQueryResultARM * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDataGraphPipelinePropertiesARM( device, pPipelineInfo, propertiesCount, pProperties );
+ }
+
+ VkResult
+ vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ uint32_t * pQueueFamilyDataGraphPropertyCount,
+ VkQueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(
+ physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties );
+ }
+
+ void vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
+ VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo,
+ VkQueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
+ physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties );
+ }
+
//=== VK_EXT_attachment_feedback_loop_dynamic_state ===
void vkCmdSetAttachmentFeedbackLoopEnableEXT( VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT
@@ -6095,6 +6277,37 @@ 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,
+ const VkExternalComputeQueueCreateInfoNV * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkExternalComputeQueueNV * pExternalQueue ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateExternalComputeQueueNV( device, pCreateInfo, pAllocator, pExternalQueue );
+ }
+
+ void vkDestroyExternalComputeQueueNV( VkDevice device,
+ VkExternalComputeQueueNV externalQueue,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyExternalComputeQueueNV( device, externalQueue, pAllocator );
+ }
+
+ void vkGetExternalComputeQueueDataNV( VkExternalComputeQueueNV externalQueue,
+ VkExternalComputeQueueDataParamsNV * params,
+ void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetExternalComputeQueueDataNV( externalQueue, params, pData );
+ }
+
//=== VK_NV_cluster_acceleration_structure ===
void vkGetClusterAccelerationStructureBuildSizesNV( VkDevice device,
@@ -6194,6 +6407,18 @@ namespace VULKAN_HPP_NAMESPACE
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 ===
VkResult vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
@@ -6219,6 +6444,13 @@ namespace VULKAN_HPP_NAMESPACE
return ::vkGetMemoryMetalHandlePropertiesEXT( device, handleType, pHandle, pMemoryMetalHandleProperties );
}
# endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+ //=== VK_EXT_fragment_density_map_offset ===
+
+ void vkCmdEndRendering2EXT( VkCommandBuffer commandBuffer, const VkRenderingEndInfoEXT * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndRendering2EXT( commandBuffer, pRenderingEndInfo );
+ }
};
inline DispatchLoaderStatic & getDispatchLoaderStatic()
@@ -6252,9 +6484,9 @@ namespace VULKAN_HPP_NAMESPACE
public:
ObjectDestroy() = default;
- ObjectDestroy( OwnerType owner,
- Optional allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
- Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+ ObjectDestroy( OwnerType owner,
+ Optional allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
@@ -6266,7 +6498,7 @@ namespace VULKAN_HPP_NAMESPACE
return m_owner;
}
- Optional getAllocator() const VULKAN_HPP_NOEXCEPT
+ Optional getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
@@ -6285,9 +6517,9 @@ namespace VULKAN_HPP_NAMESPACE
}
private:
- OwnerType m_owner = {};
- Optional m_allocationCallbacks = nullptr;
- Dispatch const * m_dispatch = nullptr;
+ OwnerType m_owner = {};
+ Optional m_allocationCallbacks = nullptr;
+ Dispatch const * m_dispatch = nullptr;
};
class NoParent;
@@ -6298,14 +6530,14 @@ namespace VULKAN_HPP_NAMESPACE
public:
ObjectDestroy() = default;
- ObjectDestroy( Optional allocationCallbacks,
- Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+ ObjectDestroy( Optional allocationCallbacks,
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{
}
- Optional getAllocator() const VULKAN_HPP_NOEXCEPT
+ Optional getAllocator() const VULKAN_HPP_NOEXCEPT
{
return m_allocationCallbacks;
}
@@ -6324,8 +6556,8 @@ namespace VULKAN_HPP_NAMESPACE
}
private:
- Optional m_allocationCallbacks = nullptr;
- Dispatch const * m_dispatch = nullptr;
+ Optional m_allocationCallbacks = nullptr;
+ Dispatch const * m_dispatch = nullptr;
};
template
@@ -6448,7 +6680,7 @@ namespace VULKAN_HPP_NAMESPACE
Dispatch const * m_dispatch = nullptr;
};
- } // namespace detail
+ } // namespace detail
#endif // !VULKAN_HPP_NO_SMART_HANDLE
//==================
@@ -6498,7 +6730,7 @@ namespace VULKAN_HPP_NAMESPACE
# if defined( VULKAN_HPP_NO_TO_STRING )
return std::to_string( ev );
# else
- return VULKAN_HPP_NAMESPACE::to_string( static_cast( ev ) );
+ return to_string( static_cast( ev ) );
# endif
}
};
@@ -6884,44 +7116,44 @@ namespace VULKAN_HPP_NAMESPACE
{
switch ( result )
{
- case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError( message );
- case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError( message );
- case Result::eErrorInitializationFailed: throw InitializationFailedError( message );
- case Result::eErrorDeviceLost: throw DeviceLostError( message );
- case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError( message );
- case Result::eErrorLayerNotPresent: throw LayerNotPresentError( message );
- case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError( message );
- case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError( message );
- case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError( message );
- case Result::eErrorTooManyObjects: throw TooManyObjectsError( message );
- case Result::eErrorFormatNotSupported: throw FormatNotSupportedError( message );
- case Result::eErrorFragmentedPool: throw FragmentedPoolError( message );
- case Result::eErrorUnknown: throw UnknownError( message );
- case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message );
- case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message );
- case Result::eErrorFragmentation: throw FragmentationError( message );
- case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError( message );
- case Result::eErrorNotPermitted: throw NotPermittedError( message );
- case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError( message );
- case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError( message );
- case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message );
- case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message );
- case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError( message );
- case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError( message );
- case Result::eErrorImageUsageNotSupportedKHR: throw ImageUsageNotSupportedKHRError( message );
- case Result::eErrorVideoPictureLayoutNotSupportedKHR: throw VideoPictureLayoutNotSupportedKHRError( message );
- case Result::eErrorVideoProfileOperationNotSupportedKHR: throw VideoProfileOperationNotSupportedKHRError( message );
- case Result::eErrorVideoProfileFormatNotSupportedKHR: throw VideoProfileFormatNotSupportedKHRError( message );
- case Result::eErrorVideoProfileCodecNotSupportedKHR: throw VideoProfileCodecNotSupportedKHRError( message );
- case Result::eErrorVideoStdVersionNotSupportedKHR: throw VideoStdVersionNotSupportedKHRError( message );
+ case Result::eErrorOutOfHostMemory : throw OutOfHostMemoryError( message );
+ case Result::eErrorOutOfDeviceMemory : throw OutOfDeviceMemoryError( message );
+ case Result::eErrorInitializationFailed : throw InitializationFailedError( message );
+ case Result::eErrorDeviceLost : throw DeviceLostError( message );
+ case Result::eErrorMemoryMapFailed : throw MemoryMapFailedError( message );
+ case Result::eErrorLayerNotPresent : throw LayerNotPresentError( message );
+ case Result::eErrorExtensionNotPresent : throw ExtensionNotPresentError( message );
+ case Result::eErrorFeatureNotPresent : throw FeatureNotPresentError( message );
+ case Result::eErrorIncompatibleDriver : throw IncompatibleDriverError( message );
+ case Result::eErrorTooManyObjects : throw TooManyObjectsError( message );
+ case Result::eErrorFormatNotSupported : throw FormatNotSupportedError( message );
+ case Result::eErrorFragmentedPool : throw FragmentedPoolError( message );
+ case Result::eErrorUnknown : throw UnknownError( message );
+ case Result::eErrorOutOfPoolMemory : throw OutOfPoolMemoryError( message );
+ case Result::eErrorInvalidExternalHandle : throw InvalidExternalHandleError( message );
+ case Result::eErrorFragmentation : throw FragmentationError( message );
+ case Result::eErrorInvalidOpaqueCaptureAddress : throw InvalidOpaqueCaptureAddressError( message );
+ case Result::eErrorNotPermitted : throw NotPermittedError( message );
+ case Result::eErrorSurfaceLostKHR : throw SurfaceLostKHRError( message );
+ case Result::eErrorNativeWindowInUseKHR : throw NativeWindowInUseKHRError( message );
+ case Result::eErrorOutOfDateKHR : throw OutOfDateKHRError( message );
+ case Result::eErrorIncompatibleDisplayKHR : throw IncompatibleDisplayKHRError( message );
+ case Result::eErrorValidationFailedEXT : throw ValidationFailedEXTError( message );
+ case Result::eErrorInvalidShaderNV : throw InvalidShaderNVError( message );
+ case Result::eErrorImageUsageNotSupportedKHR : throw ImageUsageNotSupportedKHRError( message );
+ case Result::eErrorVideoPictureLayoutNotSupportedKHR : throw VideoPictureLayoutNotSupportedKHRError( message );
+ case Result::eErrorVideoProfileOperationNotSupportedKHR : throw VideoProfileOperationNotSupportedKHRError( message );
+ case Result::eErrorVideoProfileFormatNotSupportedKHR : throw VideoProfileFormatNotSupportedKHRError( message );
+ case Result::eErrorVideoProfileCodecNotSupportedKHR : throw VideoProfileCodecNotSupportedKHRError( message );
+ case Result::eErrorVideoStdVersionNotSupportedKHR : throw VideoStdVersionNotSupportedKHRError( message );
case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
# if defined( VK_USE_PLATFORM_WIN32_KHR )
case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message );
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message );
- case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message );
- case Result::eErrorNotEnoughSpaceKHR: throw NotEnoughSpaceKHRError( message );
- default: throw SystemError( make_error_code( result ), message );
+ case Result::eErrorCompressionExhaustedEXT : throw CompressionExhaustedEXTError( message );
+ case Result::eErrorNotEnoughSpaceKHR : throw NotEnoughSpaceKHRError( message );
+ default : throw SystemError( make_error_code( result ), message );
}
}
} // namespace detail
@@ -7046,33 +7278,33 @@ namespace VULKAN_HPP_NAMESPACE
{
}
- VULKAN_HPP_INLINE typename VULKAN_HPP_NAMESPACE::ResultValueType::type createResultValueType( VULKAN_HPP_NAMESPACE::Result result )
+ VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result )
{
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
+#if defined( VULKAN_HPP_NO_EXCEPTIONS )
return result;
#else
- VULKAN_HPP_NAMESPACE::detail::ignore( result );
+ ignore( result );
#endif
}
template
- VULKAN_HPP_INLINE typename VULKAN_HPP_NAMESPACE::ResultValueType::type createResultValueType( VULKAN_HPP_NAMESPACE::Result result, T & data )
+ VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result, T & data )
{
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
+#if defined( VULKAN_HPP_NO_EXCEPTIONS )
return ResultValue( result, data );
#else
- VULKAN_HPP_NAMESPACE::detail::ignore( result );
+ ignore( result );
return data;
#endif
}
template
- VULKAN_HPP_INLINE typename VULKAN_HPP_NAMESPACE::ResultValueType::type createResultValueType( VULKAN_HPP_NAMESPACE::Result result, T && data )
+ VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result, T && data )
{
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
+#if defined( VULKAN_HPP_NO_EXCEPTIONS )
return ResultValue( result, std::move( data ) );
#else
- VULKAN_HPP_NAMESPACE::detail::ignore( result );
+ ignore( result );
return std::move( data );
#endif
}
@@ -7083,13 +7315,13 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
- VULKAN_HPP_NAMESPACE::detail::ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
- VULKAN_HPP_NAMESPACE::detail::ignore( message );
+ ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+ ignore( message );
VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
#else
if ( result != Result::eSuccess )
{
- VULKAN_HPP_NAMESPACE::detail::throwResultException( result, message );
+ throwResultException( result, message );
}
#endif
}
@@ -7097,14 +7329,14 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list successCodes )
{
#ifdef VULKAN_HPP_NO_EXCEPTIONS
- VULKAN_HPP_NAMESPACE::detail::ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
- VULKAN_HPP_NAMESPACE::detail::ignore( message );
- VULKAN_HPP_NAMESPACE::detail::ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+ ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+ ignore( message );
+ ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
#else
if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
{
- VULKAN_HPP_NAMESPACE::detail::throwResultException( result, message );
+ throwResultException( result, message );
}
#endif
}
@@ -7185,9 +7417,15 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_KHR_pipeline_binary ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPipelineBinaryKeySizeKHR = VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR;
+ //=== VK_ARM_data_graph ===
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPhysicalDeviceDataGraphOperationSetNameSizeARM = VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM;
+
//=== VK_KHR_video_decode_av1 ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoAv1ReferencesPerFrameKHR = VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR;
+ //=== VK_KHR_video_decode_vp9 ===
+ VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoVp9ReferencesPerFrameKHR = VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR;
+
//=== VK_NV_partitioned_acceleration_structure ===
VULKAN_HPP_CONSTEXPR_INLINE uint32_t PartitionedAccelerationStructurePartitionIndexGlobalNV = VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV;
@@ -7215,7 +7453,7 @@ namespace VULKAN_HPP_NAMESPACE
template ::value>::type>
VULKAN_HPP_CONSTEXPR uint32_t apiVersionPatch( T const version )
{
- return ( (uint32_t)(version)&0xFFFU );
+ return ( (uint32_t)( version ) & 0xFFFU );
}
template ::value>::type>
@@ -7255,7 +7493,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_DEPRECATED( "This define is deprecated. VK_API_VERSION_PATCH should be used instead." )
VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version )
{
- return ( (uint32_t)(version)&0xFFFU );
+ return ( (uint32_t)( version ) & 0xFFFU );
}
//=========================
@@ -7799,6 +8037,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportExtensionName = VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportSpecVersion = VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION;
+ //=== VK_KHR_shader_bfloat16 ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16ExtensionName = VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16SpecVersion = VK_KHR_SHADER_BFLOAT16_SPEC_VERSION;
+
//=== VK_EXT_sample_locations ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsExtensionName = VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsSpecVersion = VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION;
@@ -8333,6 +8575,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchSpecVersion = VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ //=== VK_QCOM_tile_shading ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingExtensionName = VK_QCOM_TILE_SHADING_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingSpecVersion = VK_QCOM_TILE_SHADING_SPEC_VERSION;
+
//=== VK_NV_low_latency ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencyExtensionName = VK_NV_LOW_LATENCY_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencySpecVersion = VK_NV_LOW_LATENCY_SPEC_VERSION;
@@ -8569,8 +8815,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 ===
@@ -8685,6 +8933,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingExtensionName = VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingSpecVersion = VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION;
+ //=== VK_ARM_tensors ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto ARMTensorsExtensionName = VK_ARM_TENSORS_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto ARMTensorsSpecVersion = VK_ARM_TENSORS_SPEC_VERSION;
+
//=== VK_EXT_shader_module_identifier ===
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierExtensionName = VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierSpecVersion = VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION;
@@ -8719,6 +8971,14 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagExtensionName = VK_AMD_ANTI_LAG_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagSpecVersion = VK_AMD_ANTI_LAG_SPEC_VERSION;
+ //=== VK_KHR_present_id2 ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2ExtensionName = VK_KHR_PRESENT_ID_2_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2SpecVersion = VK_KHR_PRESENT_ID_2_SPEC_VERSION;
+
+ //=== VK_KHR_present_wait2 ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWait2ExtensionName = VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWait2SpecVersion = VK_KHR_PRESENT_WAIT_2_SPEC_VERSION;
+
//=== VK_KHR_ray_tracing_position_fetch ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchExtensionName = VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchSpecVersion = VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION;
@@ -8787,6 +9047,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixExtensionName = VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixSpecVersion = VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION;
+ //=== VK_ARM_data_graph ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphExtensionName = VK_ARM_DATA_GRAPH_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphSpecVersion = VK_ARM_DATA_GRAPH_SPEC_VERSION;
+
//=== VK_QCOM_multiview_per_view_render_areas ===
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION;
@@ -8803,6 +9067,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeAv1ExtensionName = VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeAv1SpecVersion = VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION;
+ //=== VK_KHR_video_decode_vp9 ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeVp9ExtensionName = VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeVp9SpecVersion = VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION;
+
//=== VK_KHR_video_maintenance1 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1ExtensionName = VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1SpecVersion = VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION;
@@ -8839,6 +9107,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneExtensionName = VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneSpecVersion = VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION;
+ //=== VK_KHR_unified_image_layouts ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRUnifiedImageLayoutsExtensionName = VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRUnifiedImageLayoutsSpecVersion = VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION;
+
//=== VK_KHR_shader_float_controls2 ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2ExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2SpecVersion = VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION;
@@ -8877,6 +9149,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;
@@ -8889,6 +9165,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsExtensionName = VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsSpecVersion = VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION;
+ //=== VK_NV_external_compute_queue ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueExtensionName = VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueSpecVersion = VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION;
+
//=== VK_KHR_shader_relaxed_extended_instruction ===
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION;
@@ -8909,6 +9189,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesExtensionName = VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesSpecVersion = VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION;
+ //=== VK_EXT_shader_float8 ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderFloat8ExtensionName = VK_EXT_SHADER_FLOAT8_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderFloat8SpecVersion = VK_EXT_SHADER_FLOAT8_SPEC_VERSION;
+
//=== VK_NV_ray_tracing_validation ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationExtensionName = VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationSpecVersion = VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION;
@@ -8937,10 +9221,20 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlExtensionName = VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlSpecVersion = VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION;
+ //=== VK_KHR_maintenance9 ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance9ExtensionName = VK_KHR_MAINTENANCE_9_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance9SpecVersion = VK_KHR_MAINTENANCE_9_SPEC_VERSION;
+
//=== VK_KHR_video_maintenance2 ===
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;
@@ -8967,19 +9261,38 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessExtensionName = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION;
+ //=== VK_ARM_format_pack ===
+ 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;
+
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_NV_present_metering ===
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringExtensionName = VK_NV_PRESENT_METERING_EXTENSION_NAME;
VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringSpecVersion = VK_NV_PRESENT_METERING_SPEC_VERSION;
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ //=== VK_EXT_fragment_density_map_offset ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION;
+
+ //=== VK_EXT_zero_initialize_device_memory ===
+ VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemoryExtensionName = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME;
+ VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemorySpecVersion = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION;
+
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
#include
#include