kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-06-03 07:08:15 +02:00
Code Issues Packages Projects Releases Wiki Activity

fixing infinite descriptor pool creation bug (#169)

Browse Source
This commit is contained in:
kbz_8
2025-11-04 20:58:41 +01:00
committed by GitHub
parent 459da42580 3a63f0c613
commit d71a5566b6
23 changed files with 18899 additions and 13328 deletions
Download Patch File Download Diff File Expand all files Collapse all files
runtime/Includes/Graphics/Drawable.h
+1 -1
View File
@@ -38,7 +38,7 @@ namespace mlx
inline void UpdateDescriptorSet(std::shared_ptr<DescriptorSet> set)
{
p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(set->GetShaderLayout(), set->GetShaderType());
p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool(set->GetShaderLayout(), set->GetShaderType()).RequestDescriptorSet(set->GetShaderLayout(), set->GetShaderType());
}
virtual void Bind(std::size_t frame_index, VkCommandBuffer cmd) = 0;
runtime/Includes/Renderer/Descriptor.h
+2 -3
View File
@@ -26,9 +26,9 @@ namespace mlx
std::shared_ptr<class DescriptorSet> RequestDescriptorSet(const ShaderSetLayout& layout, ShaderType shader_type);
void ReturnDescriptorSet(std::shared_ptr<class DescriptorSet> set);
bool CanAllocate(const ShaderSetLayout& layout, ShaderType shader_type) const;
[[nodiscard]] inline VkDescriptorPool Get() const noexcept { return m_pool; }
[[nodiscard]] MLX_FORCEINLINE std::size_t GetNumberOfSetsAllocated() const noexcept { return m_allocation_count; }
~DescriptorPool() = default;
@@ -36,7 +36,6 @@ namespace mlx
std::vector<std::shared_ptr<class DescriptorSet>> m_free_sets;
std::vector<std::shared_ptr<class DescriptorSet>> m_used_sets;
VkDescriptorPool m_pool;
std::size_t m_allocation_count = 0;
};
class DescriptorPoolManager
@@ -44,7 +43,7 @@ namespace mlx
public:
DescriptorPoolManager() = default;
DescriptorPool& GetAvailablePool();
DescriptorPool& GetAvailablePool(const ShaderSetLayout& layout, ShaderType shader_type);
void Destroy();
~DescriptorPoolManager() = default;
runtime/Sources/Core/SDLManager.cpp
+1 -1
View File
@@ -25,7 +25,7 @@ namespace mlx
m_drop_sdl_responsability = SDL_WasInit(SDL_INIT_VIDEO) || std::getenv("MLX_HEADLESS_MODE") != nullptr;
if(m_drop_sdl_responsability) // is case the mlx is running in a sandbox like MacroUnitTester where SDL is already init
return;
SDL_SetMemoryFunctions(MemManager::Get().Malloc, MemManager::Get().Calloc, MemManager::Get().Realloc, MemManager::Get().Free);
//SDL_SetMemoryFunctions(MemManager::Get().Malloc, MemManager::Get().Calloc, MemManager::Get().Realloc, MemManager::Get().Free);
#ifdef FORCE_WAYLAND
SDL_SetHint(SDL_HINT_VIDEODRIVER, "wayland,x11");
runtime/Sources/Renderer/Descriptor.cpp
+19 -10
View File
@@ -9,7 +9,7 @@
namespace mlx
{
constexpr std::size_t MAX_SETS_PER_POOL = MAX_FRAMES_IN_FLIGHT * 1024;
constexpr std::size_t MAX_SETS_PER_POOL = 1024;
void TransitionImageToCorrectLayout(Image& image, VkCommandBuffer cmd)
{
@@ -26,19 +26,19 @@ namespace mlx
{
MLX_PROFILE_FUNCTION();
VkDescriptorPoolSize pool_sizes[] = {
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_SETS_PER_POOL }
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, MAX_FRAMES_IN_FLIGHT * MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MAX_FRAMES_IN_FLIGHT * MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_FRAMES_IN_FLIGHT * MAX_SETS_PER_POOL }
};
VkDescriptorPoolCreateInfo pool_info{};
pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
pool_info.poolSizeCount = sizeof(pool_sizes) / sizeof(pool_sizes[0]);
pool_info.pPoolSizes = pool_sizes;
pool_info.maxSets = MAX_SETS_PER_POOL;
pool_info.maxSets = MAX_FRAMES_IN_FLIGHT * MAX_SETS_PER_POOL;
pool_info.flags = 0;
kvfCheckVk(RenderCore::Get().vkCreateDescriptorPool(RenderCore::Get().GetDevice(), &pool_info, nullptr, &m_pool));
m_allocation_count = 0;
DebugLog("Vulkan: created new descriptor pool");
}
void DescriptorPool::Destroy() noexcept
@@ -52,7 +52,6 @@ namespace mlx
kvfDestroyDescriptorSetLayout(RenderCore::Get().GetDevice(), set->m_set_layout);
RenderCore::Get().vkDestroyDescriptorPool(RenderCore::Get().GetDevice(), m_pool, nullptr);
m_pool = VK_NULL_HANDLE;
m_allocation_count = 0;
m_free_sets.clear();
m_used_sets.clear();
}
@@ -103,7 +102,6 @@ namespace mlx
alloc_info.pSetLayouts = &vulkan_layout;
VkDescriptorSet vulkan_set;
kvfCheckVk(RenderCore::Get().vkAllocateDescriptorSets(RenderCore::Get().GetDevice(), &alloc_info, &vulkan_set));
m_allocation_count++;
vulkan_sets[i] = vulkan_set;
}
@@ -124,12 +122,23 @@ namespace mlx
m_free_sets.push_back(set);
}
DescriptorPool& DescriptorPoolManager::GetAvailablePool()
bool DescriptorPool::CanAllocate(const ShaderSetLayout& layout, ShaderType shader_type) const
{
auto it = std::find_if(m_free_sets.begin(), m_free_sets.end(), [&](std::shared_ptr<DescriptorSet> set)
{
return shader_type == set->GetShaderType() && layout == set->GetShaderLayout();
});
if(it != m_free_sets.end())
return true;
return m_used_sets.size() + m_free_sets.size() < MAX_SETS_PER_POOL;
}
DescriptorPool& DescriptorPoolManager::GetAvailablePool(const ShaderSetLayout& layout, ShaderType shader_type)
{
MLX_PROFILE_FUNCTION();
for(auto& pool : m_pools)
{
if(pool->GetNumberOfSetsAllocated() < MAX_SETS_PER_POOL)
if(pool->CanAllocate(layout, shader_type))
return *pool;
}
m_pools.emplace_back(std::make_unique<DescriptorPool>())->Init();
runtime/Sources/Renderer/RenderPasses/2DPass.cpp
+2 -2
View File
@@ -52,8 +52,8 @@ namespace mlx
};
EventBus::RegisterListener({ functor, "mlx_2d_render_pass_" + std::to_string(reinterpret_cast<std::uintptr_t>(this)) });
p_viewer_data_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_vertex_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Vertex);
p_texture_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
p_viewer_data_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool(p_vertex_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Vertex).RequestDescriptorSet(p_vertex_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Vertex);
p_texture_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment).RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
p_viewer_data_buffer = std::make_shared<UniformBuffer>();
p_viewer_data_buffer->Init(sizeof(ViewerData), "mlx_2d_pass_viewer_data");
runtime/Sources/Renderer/RenderPasses/FinalPass.cpp
+1 -1
View File
@@ -38,7 +38,7 @@ namespace mlx
};
EventBus::RegisterListener({ functor, "mlx_final_pass_" + std::to_string(reinterpret_cast<std::uintptr_t>(this)) });
p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment).RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
}
void FinalPass::Pass([[maybe_unused]] Scene& scene, Renderer& renderer, Texture& render_target, NonOwningPtr<class Texture> final_target)
third_party/vk_video/vulkan_video_codec_av1std.h
Vendored
+1 -1
View File
@@ -144,7 +144,7 @@ typedef enum StdVideoAV1ColorPrimaries {
STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12,
STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22,
STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF,
// STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED is a deprecated alias
// STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED is a legacy alias
STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF
} StdVideoAV1ColorPrimaries;
third_party/vulkan/vulkan.cppm
Vendored
+461 -266
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan.hpp
Vendored
+1964 -1531
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_core.h
Vendored
+2126 -1895
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_enums.hpp
Vendored
+1329 -1191
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_extension_inspection.hpp
Vendored
+213 -89
View File
@@ -397,6 +397,9 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_image_compression_control_swapchain",
"VK_QCOM_image_processing",
"VK_EXT_nested_command_buffer",
#if defined( VK_USE_PLATFORM_OHOS )
"VK_OHOS_external_memory",
#endif /*VK_USE_PLATFORM_OHOS*/
"VK_EXT_external_memory_acquire_unmodified",
"VK_EXT_extended_dynamic_state3",
"VK_EXT_subpass_merge_feedback",
@@ -462,6 +465,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_NV_descriptor_pool_overallocation",
"VK_QCOM_tile_memory_heap",
"VK_KHR_copy_memory_indirect",
"VK_EXT_memory_decompression",
"VK_KHR_video_encode_intra_refresh",
"VK_KHR_video_encode_quantization_map",
"VK_NV_raw_access_chains",
@@ -482,6 +486,9 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_depth_clamp_control",
"VK_KHR_maintenance9",
"VK_KHR_video_maintenance2",
#if defined( VK_USE_PLATFORM_OHOS )
"VK_OHOS_native_buffer",
#endif /*VK_USE_PLATFORM_OHOS*/
"VK_HUAWEI_hdr_vivid",
"VK_NV_cooperative_matrix2",
"VK_ARM_pipeline_opacity_micromap",
@@ -489,6 +496,7 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_external_memory_metal",
#endif /*VK_USE_PLATFORM_METAL_EXT*/
"VK_KHR_depth_clamp_zero_one",
"VK_ARM_performance_counters_by_region",
"VK_EXT_vertex_attribute_robustness",
"VK_ARM_format_pack",
"VK_VALVE_fragment_density_map_layered",
@@ -499,7 +507,10 @@ namespace VULKAN_HPP_NAMESPACE
"VK_EXT_fragment_density_map_offset",
"VK_EXT_zero_initialize_device_memory",
"VK_KHR_present_mode_fifo_latest_ready",
"VK_SEC_pipeline_cache_incremental_mode" };
"VK_EXT_shader_64bit_indexing",
"VK_KHR_maintenance10",
"VK_SEC_pipeline_cache_incremental_mode",
"VK_EXT_shader_uniform_buffer_unsized_array" };
return deviceExtensions;
}
@@ -600,42 +611,48 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_display",
"VK_KHR_swapchain",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_XLIB_KHR )
,
{ "VK_KHR_xlib_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_XLIB_KHR*/
#if defined( VK_USE_PLATFORM_XCB_KHR )
,
{ "VK_KHR_xcb_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_XCB_KHR*/
#if defined( VK_USE_PLATFORM_WAYLAND_KHR )
,
{ "VK_KHR_wayland_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
,
{ "VK_KHR_android_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
#if defined( VK_USE_PLATFORM_WIN32_KHR )
,
{ "VK_KHR_win32_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
,
{ "VK_EXT_debug_marker",
{ { "VK_VERSION_1_0",
{ {
@@ -694,14 +711,16 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_depth_stencil_resolve",
} } },
{ "VK_VERSION_1_2", { {} } } } },
{ "VK_VERSION_1_2", { {} } } } }
#if defined( VK_USE_PLATFORM_GGP )
,
{ "VK_GGP_stream_descriptor_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_GGP*/
,
{ "VK_NV_corner_sampled_image",
{ { "VK_VERSION_1_0",
{ {
@@ -718,8 +737,9 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_NV_external_memory_capabilities",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_WIN32_KHR )
,
{ "VK_NV_external_memory_win32",
{ { "VK_VERSION_1_0",
{ {
@@ -729,20 +749,23 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_NV_external_memory_win32",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
,
{ "VK_KHR_device_group",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_device_group_creation",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_VI_NN )
,
{ "VK_NN_vi_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_VI_NN*/
,
{ "VK_EXT_texture_compression_astc_hdr",
{ { "VK_VERSION_1_0",
{ {
@@ -772,28 +795,32 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_external_memory_capabilities",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_WIN32_KHR )
,
{ "VK_KHR_external_memory_win32",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_external_memory",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
,
{ "VK_KHR_external_memory_fd",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_external_memory",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_WIN32_KHR )
,
{ "VK_KHR_win32_keyed_mutex",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_external_memory_win32",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
,
{ "VK_KHR_external_semaphore_capabilities",
{ { "VK_VERSION_1_0",
{ {
@@ -804,14 +831,16 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_external_semaphore_capabilities",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_WIN32_KHR )
,
{ "VK_KHR_external_semaphore_win32",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_external_semaphore",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
,
{ "VK_KHR_external_semaphore_fd",
{ { "VK_VERSION_1_0",
{ {
@@ -852,14 +881,16 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_display",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
,
{ "VK_EXT_acquire_xlib_display",
{ { "VK_VERSION_1_0",
{ {
"VK_EXT_direct_mode_display",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
,
{ "VK_EXT_display_surface_counter",
{ { "VK_VERSION_1_0",
{ {
@@ -957,14 +988,16 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_external_fence_capabilities",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_WIN32_KHR )
,
{ "VK_KHR_external_fence_win32",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_external_fence",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
,
{ "VK_KHR_external_fence_fd",
{ { "VK_VERSION_1_0",
{ {
@@ -993,21 +1026,24 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_display",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_IOS_MVK )
,
{ "VK_MVK_ios_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_IOS_MVK*/
#if defined( VK_USE_PLATFORM_MACOS_MVK )
,
{ "VK_MVK_macos_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
,
{ "VK_EXT_external_memory_dma_buf",
{ { "VK_VERSION_1_0",
{ {
@@ -1024,8 +1060,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_get_memory_requirements2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
,
{ "VK_ANDROID_external_memory_android_hardware_buffer",
{ { "VK_VERSION_1_0",
{ {
@@ -1037,15 +1074,17 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_VERSION_1_1",
{ {
"VK_EXT_queue_family_foreign",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
,
{ "VK_EXT_sampler_filter_minmax",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_ENABLE_BETA_EXTENSIONS )
,
{ "VK_AMDX_shader_enqueue",
{ { "VK_VERSION_1_0",
{ {
@@ -1059,8 +1098,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_maintenance5",
"VK_KHR_pipeline_library",
} } } } },
} } } } }
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
,
{ "VK_EXT_inline_uniform_block",
{ { "VK_VERSION_1_0",
{ {
@@ -1146,15 +1186,17 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
"VK_KHR_maintenance3",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_ENABLE_BETA_EXTENSIONS )
,
{ "VK_KHR_portability_subset",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
,
{ "VK_NV_shading_rate_image",
{ { "VK_VERSION_1_0",
{ {
@@ -1234,15 +1276,17 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_GGP )
,
{ "VK_GGP_frame_token",
{ { "VK_VERSION_1_0",
{ {
"VK_GGP_stream_descriptor_surface",
"VK_KHR_swapchain",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_GGP*/
,
{ "VK_KHR_driver_properties",
{ { "VK_VERSION_1_0",
{ {
@@ -1349,27 +1393,31 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_get_surface_capabilities2",
"VK_KHR_swapchain",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_FUCHSIA )
,
{ "VK_FUCHSIA_imagepipe_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_FUCHSIA*/
,
{ "VK_KHR_shader_terminate_invocation",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_METAL_EXT )
,
{ "VK_EXT_metal_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_METAL_EXT*/
,
{ "VK_EXT_fragment_density_map",
{ { "VK_VERSION_1_0",
{ {
@@ -1518,8 +1566,9 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_WIN32_KHR )
,
{ "VK_EXT_full_screen_exclusive",
{ { "VK_VERSION_1_0",
{ {
@@ -1533,8 +1582,9 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_surface_capabilities2",
"VK_KHR_surface",
"VK_KHR_swapchain",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
,
{ "VK_EXT_headless_surface",
{ { "VK_VERSION_1_0",
{ {
@@ -1881,21 +1931,24 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_sampler_ycbcr_conversion",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_WIN32_KHR )
,
{ "VK_NV_acquire_winrt_display",
{ { "VK_VERSION_1_0",
{ {
"VK_EXT_direct_mode_display",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
#if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
,
{ "VK_EXT_directfb_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
,
{ "VK_VALVE_mutable_descriptor_type",
{ { "VK_VERSION_1_0",
{ {
@@ -1945,8 +1998,9 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_swapchain",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_FUCHSIA )
,
{ "VK_FUCHSIA_external_memory",
{ { "VK_VERSION_1_0",
{ {
@@ -1969,8 +2023,9 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_VERSION_1_1",
{ {
"VK_FUCHSIA_external_memory",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_FUCHSIA*/
,
{ "VK_HUAWEI_subpass_shading",
{ { "VK_VERSION_1_0",
{ {
@@ -2016,14 +2071,16 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
,
{ "VK_QNX_screen_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
,
{ "VK_EXT_color_write_enable",
{ { "VK_VERSION_1_0",
{ {
@@ -2094,14 +2151,16 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_VERSION_1_3",
{ {
"VK_KHR_acceleration_structure",
} } } } },
} } } } }
#if defined( VK_ENABLE_BETA_EXTENSIONS )
,
{ "VK_NV_displacement_micromap",
{ { "VK_VERSION_1_0",
{ {
"VK_EXT_opacity_micromap",
} } } } },
} } } } }
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
,
{ "VK_HUAWEI_cluster_culling_shader",
{ { "VK_VERSION_1_0",
{ {
@@ -2231,7 +2290,23 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_OHOS )
,
{ "VK_OHOS_external_memory",
{ { "VK_VERSION_1_0",
{ {
"VK_EXT_queue_family_foreign",
"VK_KHR_dedicated_allocation",
"VK_KHR_external_memory",
"VK_KHR_sampler_ycbcr_conversion",
} } },
{ "VK_VERSION_1_1",
{ {
"VK_EXT_queue_family_foreign",
} } } } }
#endif /*VK_USE_PLATFORM_OHOS*/
,
{ "VK_EXT_external_memory_acquire_unmodified",
{ { "VK_VERSION_1_0",
{ {
@@ -2292,21 +2367,24 @@ namespace VULKAN_HPP_NAMESPACE
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#if defined( VK_USE_PLATFORM_ANDROID_KHR )
,
{ "VK_ANDROID_external_format_resolve",
{ { "VK_VERSION_1_0",
{ {
"VK_ANDROID_external_memory_android_hardware_buffer",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
,
{ "VK_KHR_maintenance5",
{ { "VK_VERSION_1_1",
{ {
"VK_KHR_dynamic_rendering",
} } },
{ "VK_VERSION_1_3", { {} } } } },
{ "VK_VERSION_1_3", { {} } } } }
#if defined( VK_ENABLE_BETA_EXTENSIONS )
,
{ "VK_AMDX_dense_geometry_format",
{ { "VK_VERSION_1_0",
{ {
@@ -2316,8 +2394,9 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_VERSION_1_4",
{ {
"VK_KHR_acceleration_structure",
} } } } },
} } } } }
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
,
{ "VK_KHR_present_id2",
{ { "VK_VERSION_1_0",
{ {
@@ -2532,8 +2611,9 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_1",
{ {
"VK_KHR_shader_float_controls",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_SCREEN_QNX )
,
{ "VK_QNX_external_memory_screen_buffer",
{ { "VK_VERSION_1_0",
{ {
@@ -2545,8 +2625,9 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_VERSION_1_1",
{ {
"VK_EXT_queue_family_foreign",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_SCREEN_QNX*/
,
{ "VK_MSFT_layered_driver",
{ { "VK_VERSION_1_0",
{ {
@@ -2593,6 +2674,12 @@ namespace VULKAN_HPP_NAMESPACE
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_2", { {} } } } },
{ "VK_EXT_memory_decompression",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_buffer_device_address",
"VK_KHR_get_physical_device_properties2",
} } } } },
{ "VK_NV_display_stereo",
{ { "VK_VERSION_1_0",
{ {
@@ -2659,14 +2746,16 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_video_queue",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_OHOS )
,
{ "VK_OHOS_surface",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_surface",
} } } } },
} } } } }
#endif /*VK_USE_PLATFORM_OHOS*/
,
{ "VK_HUAWEI_hdr_vivid",
{ { "VK_VERSION_1_0",
{ {
@@ -2688,21 +2777,29 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_EXT_opacity_micromap",
} } } } },
} } } } }
#if defined( VK_USE_PLATFORM_METAL_EXT )
,
{ "VK_EXT_external_memory_metal",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_external_memory",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_VERSION_1_1", { {} } } } }
#endif /*VK_USE_PLATFORM_METAL_EXT*/
,
{ "VK_KHR_depth_clamp_zero_one",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_ARM_performance_counters_by_region",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_EXT_vertex_attribute_robustness",
{ { "VK_VERSION_1_0",
{ {
@@ -2758,7 +2855,19 @@ namespace VULKAN_HPP_NAMESPACE
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_swapchain",
} } } } }
} } } } },
{ "VK_EXT_shader_64bit_indexing",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } },
{ "VK_KHR_maintenance10",
{ { "VK_VERSION_1_0",
{ {
"VK_KHR_get_physical_device_properties2",
} } },
{ "VK_VERSION_1_1", { {} } } } }
};
auto depIt = dependencies.find( extension );
return ( depIt != dependencies.end() ) ? depIt->second : noDependencies;
@@ -2902,6 +3011,7 @@ namespace VULKAN_HPP_NAMESPACE
{ "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" },
{ "VK_QCOM_fragment_density_map_offset", "VK_EXT_fragment_density_map_offset" },
{ "VK_NV_copy_memory_indirect", "VK_KHR_copy_memory_indirect" },
{ "VK_NV_memory_decompression", "VK_EXT_memory_decompression" },
{ "VK_EXT_pipeline_protected_access", "VK_VERSION_1_4" },
{ "VK_KHR_maintenance5", "VK_VERSION_1_4" },
{ "VK_KHR_vertex_attribute_divisor", "VK_VERSION_1_4" },
@@ -3406,6 +3516,10 @@ namespace VULKAN_HPP_NAMESPACE
{
return "VK_KHR_copy_memory_indirect";
}
if ( extension == "VK_NV_memory_decompression" )
{
return "VK_EXT_memory_decompression";
}
if ( extension == "VK_EXT_pipeline_protected_access" )
{
return "VK_VERSION_1_4";
@@ -3453,23 +3567,23 @@ namespace VULKAN_HPP_NAMESPACE
{
return ( extension == "VK_EXT_debug_report" ) || ( extension == "VK_NV_glsl_shader" ) || ( extension == "VK_NV_dedicated_allocation" ) ||
( extension == "VK_AMD_gpu_shader_half_float" ) || ( extension == "VK_IMG_format_pvrtc" ) || ( extension == "VK_NV_external_memory_capabilities" ) ||
( extension == "VK_NV_external_memory" ) ||
( extension == "VK_NV_external_memory" )
#if defined( VK_USE_PLATFORM_WIN32_KHR )
( extension == "VK_NV_external_memory_win32" ) ||
|| ( extension == "VK_NV_external_memory_win32" )
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
( extension == "VK_EXT_validation_flags" ) || ( extension == "VK_EXT_shader_subgroup_ballot" ) || ( extension == "VK_EXT_shader_subgroup_vote" ) ||
|| ( extension == "VK_EXT_validation_flags" ) || ( extension == "VK_EXT_shader_subgroup_ballot" ) || ( extension == "VK_EXT_shader_subgroup_vote" )
#if defined( VK_USE_PLATFORM_IOS_MVK )
( extension == "VK_MVK_ios_surface" ) ||
|| ( extension == "VK_MVK_ios_surface" )
#endif /*VK_USE_PLATFORM_IOS_MVK*/
#if defined( VK_USE_PLATFORM_MACOS_MVK )
( extension == "VK_MVK_macos_surface" ) ||
|| ( extension == "VK_MVK_macos_surface" )
#endif /*VK_USE_PLATFORM_MACOS_MVK*/
( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) ||
( extension == "VK_EXT_validation_features" ) ||
|| ( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) ||
( extension == "VK_EXT_validation_features" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
( extension == "VK_NV_displacement_micromap" ) ||
|| ( extension == "VK_NV_displacement_micromap" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
false;
|| false;
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension )
@@ -3638,8 +3752,11 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_NV_device_generated_commands_compute" ) ||
( extension == "VK_NV_ray_tracing_linear_swept_spheres" ) || ( extension == "VK_NV_linear_color_attachment" ) ||
( extension == "VK_KHR_shader_maximal_reconvergence" ) || ( extension == "VK_EXT_image_compression_control_swapchain" ) ||
( extension == "VK_QCOM_image_processing" ) || ( extension == "VK_EXT_nested_command_buffer" ) ||
( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) ||
( extension == "VK_QCOM_image_processing" ) || ( extension == "VK_EXT_nested_command_buffer" )
#if defined( VK_USE_PLATFORM_OHOS )
|| ( extension == "VK_OHOS_external_memory" )
#endif /*VK_USE_PLATFORM_OHOS*/
|| ( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) ||
( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_ARM_tensors" ) || ( extension == "VK_EXT_shader_module_identifier" ) ||
( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) ||
( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" )
@@ -3671,27 +3788,33 @@ namespace VULKAN_HPP_NAMESPACE
|| ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_QCOM_tile_memory_heap" ) ||
( extension == "VK_KHR_copy_memory_indirect" ) || ( extension == "VK_KHR_video_encode_intra_refresh" ) ||
( extension == "VK_KHR_video_encode_quantization_map" ) || ( extension == "VK_NV_raw_access_chains" ) ||
( extension == "VK_NV_external_compute_queue" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) ||
( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) ||
( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) ||
( extension == "VK_EXT_shader_float8" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) ||
( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) ||
( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) ||
( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
( extension == "VK_KHR_copy_memory_indirect" ) || ( extension == "VK_EXT_memory_decompression" ) ||
( extension == "VK_KHR_video_encode_intra_refresh" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) ||
( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) ||
( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) ||
( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_EXT_shader_float8" ) ||
( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) ||
( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) ||
( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) ||
( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" )
#if defined( VK_USE_PLATFORM_OHOS )
|| ( extension == "VK_OHOS_native_buffer" )
#endif /*VK_USE_PLATFORM_OHOS*/
|| ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" )
#if defined( VK_USE_PLATFORM_METAL_EXT )
|| ( extension == "VK_EXT_external_memory_metal" )
#endif /*VK_USE_PLATFORM_METAL_EXT*/
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_EXT_vertex_attribute_robustness" ) || ( extension == "VK_ARM_format_pack" ) ||
|| ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_ARM_performance_counters_by_region" ) ||
( extension == "VK_EXT_vertex_attribute_robustness" ) || ( extension == "VK_ARM_format_pack" ) ||
( extension == "VK_VALVE_fragment_density_map_layered" ) || ( extension == "VK_KHR_robustness2" )
#if defined( VK_ENABLE_BETA_EXTENSIONS )
|| ( extension == "VK_NV_present_metering" )
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
|| ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) ||
( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" );
( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) ||
( extension == "VK_KHR_maintenance10" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) ||
( extension == "VK_EXT_shader_uniform_buffer_unsized_array" );
}
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
@@ -3767,11 +3890,11 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension )
{
return ( extension == "VK_KHR_sampler_mirror_clamp_to_edge" ) || ( extension == "VK_EXT_debug_marker" ) || ( extension == "VK_AMD_draw_indirect_count" ) ||
( extension == "VK_KHR_dynamic_rendering" ) || ( extension == "VK_KHR_multiview" ) ||
( extension == "VK_KHR_dynamic_rendering" ) || ( extension == "VK_KHR_multiview" )
#if defined( VK_USE_PLATFORM_WIN32_KHR )
( extension == "VK_NV_win32_keyed_mutex" ) ||
|| ( extension == "VK_NV_win32_keyed_mutex" )
#endif /*VK_USE_PLATFORM_WIN32_KHR*/
( extension == "VK_KHR_get_physical_device_properties2" ) || ( extension == "VK_KHR_device_group" ) ||
|| ( extension == "VK_KHR_get_physical_device_properties2" ) || ( extension == "VK_KHR_device_group" ) ||
( extension == "VK_KHR_shader_draw_parameters" ) || ( extension == "VK_EXT_texture_compression_astc_hdr" ) ||
( extension == "VK_EXT_pipeline_robustness" ) || ( extension == "VK_KHR_maintenance1" ) || ( extension == "VK_KHR_device_group_creation" ) ||
( extension == "VK_KHR_external_memory_capabilities" ) || ( extension == "VK_KHR_external_memory" ) ||
@@ -3808,7 +3931,8 @@ namespace VULKAN_HPP_NAMESPACE
( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_global_priority_query" ) ||
( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) ||
( extension == "VK_EXT_depth_clamp_zero_one" ) || ( extension == "VK_QCOM_fragment_density_map_offset" ) ||
( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_NV_memory_decompression" ) ||
( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) ||
( extension == "VK_KHR_vertex_attribute_divisor" ) || ( extension == "VK_KHR_load_store_op_none" ) ||
( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || ( extension == "VK_EXT_vertex_attribute_robustness" );
third_party/vulkan/vulkan_funcs.hpp
Vendored
+2867 -2369
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_handles.hpp
Vendored
+1801 -1630
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_hash.hpp
Vendored
+399 -60
View File
@@ -94,15 +94,6 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::Event>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
{
@@ -121,15 +112,6 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::BufferView>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::Image>
{
@@ -148,6 +130,42 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::Event>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::BufferView>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
{
@@ -238,35 +256,8 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
}
};
//=== VK_VERSION_1_1 ===
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
{
@@ -276,6 +267,15 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
{
return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
}
};
//=== VK_VERSION_1_3 ===
template <>
@@ -3858,6 +3858,35 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT const & decompressMemoryRegionEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.srcAddress );
VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.dstAddress );
VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.compressedSize );
VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.decompressedSize );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT const & decompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.decompressionMethod );
VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.regionCount );
VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pRegions );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV>
{
@@ -5803,6 +5832,21 @@ namespace std
};
# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatOHOS const & externalFormatOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.externalFormat );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_SCREEN_QNX )
template <>
struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatQNX>
@@ -7431,6 +7475,21 @@ namespace std
};
# endif /*VK_USE_PLATFORM_METAL_EXT*/
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS const & importNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.buffer );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_SCREEN_QNX )
template <>
struct hash<VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX>
@@ -8020,6 +8079,21 @@ namespace std
};
# endif /*VK_USE_PLATFORM_METAL_EXT*/
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS const & memoryGetNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.memory );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
{
@@ -8428,6 +8502,74 @@ namespace std
}
};
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS const & nativeBufferFormatPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.format );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.externalFormat );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.formatFeatures );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.samplerYcbcrConversionComponents );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrModel );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrRange );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedXChromaOffset );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYChromaOffset );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::NativeBufferOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferOHOS const & nativeBufferOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.handle );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS const & nativeBufferPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.allocationSize );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.memoryTypeBits );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS const & nativeBufferUsageOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.OHOSNativeBufferUsage );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT>
{
@@ -8654,6 +8796,36 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterARM const & performanceCounterARM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.sType );
VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.counterID );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM const & performanceCounterDescriptionARM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.sType );
VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.flags );
for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
{
VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.name[i] );
}
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>
{
@@ -11526,6 +11698,36 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR const & physicalDeviceMaintenance10FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.maintenance10 );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR const & physicalDeviceMaintenance10PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.rgba4OpaqueBlackSwizzled );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatAppliesTransferFunction );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatSupportsTransferFunctionControl );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
{
@@ -11755,30 +11957,30 @@ namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV const & physicalDeviceMemoryDecompressionFeaturesNV ) const
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT const & physicalDeviceMemoryDecompressionFeaturesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.memoryDecompression );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.memoryDecompression );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV const & physicalDeviceMemoryDecompressionPropertiesNV ) const
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT const & physicalDeviceMemoryDecompressionPropertiesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.decompressionMethods );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.maxDecompressionIndirectCount );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.decompressionMethods );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.maxDecompressionIndirectCount );
return seed;
}
};
@@ -12258,6 +12460,38 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM const &
physicalDevicePerformanceCountersByRegionFeaturesARM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.performanceCountersByRegion );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM const &
physicalDevicePerformanceCountersByRegionPropertiesARM ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.maxPerRegionPerformanceCounters );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.performanceCounterRegionSize );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.rowStrideAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.regionAlignment );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.identityTransformOrder );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR>
{
@@ -12607,6 +12841,22 @@ namespace std
}
};
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS>
{
std::size_t
operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS const & physicalDevicePresentationPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.sharedImage );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
{
@@ -13150,6 +13400,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT const & physicalDeviceShader64BitIndexingFeaturesEXT ) const
VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.shader64BitIndexing );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>
{
@@ -13845,6 +14109,20 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const &
physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.shaderUniformBufferUnsizedArray );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR>
{
@@ -16722,6 +17000,24 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM const & renderPassPerformanceCountersByRegionBeginInfoARM )
const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.sType );
VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pNext );
VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterAddressCount );
VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterAddresses );
VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.serializeRegions );
VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterIndexCount );
VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterIndices );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>
{
@@ -16882,6 +17178,19 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR const & renderingAttachmentFlagsInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.flags );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo>
{
@@ -16897,13 +17206,13 @@ namespace std
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>
struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT const & renderingEndInfoEXT ) const VULKAN_HPP_NOEXCEPT
std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR const & renderingEndInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.pNext );
return seed;
}
};
@@ -16993,6 +17302,21 @@ namespace std
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR const & resolveImageModeInfoKHR ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.sType );
VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.pNext );
VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.flags );
VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.resolveMode );
VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.stencilResolveMode );
return seed;
}
};
template <>
struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM>
{
@@ -17989,6 +18313,21 @@ namespace std
}
};
# if defined( VK_USE_PLATFORM_OHOS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS>
{
std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS const & swapchainImageCreateInfoOHOS ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.sType );
VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.pNext );
VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.usage );
return seed;
}
};
# endif /*VK_USE_PLATFORM_OHOS*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>
{
third_party/vulkan/vulkan_hpp_macros.hpp
Vendored
-6
View File
@@ -307,15 +307,9 @@ namespace VULKAN_HPP_NAMESPACE
#endif
#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment )
#else
# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) = assignment
#endif
#if !defined( VULKAN_HPP_RAII_NAMESPACE )
third_party/vulkan/vulkan_ohos.h
Vendored
+131
View File
@@ -19,6 +19,75 @@ extern "C" {
// VK_OHOS_external_memory is a preprocessor guard. Do not pass it to API calls.
#define VK_OHOS_external_memory 1
struct OH_NativeBuffer;
#define VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION 2
#define VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME "VK_OHOS_external_memory"
typedef struct VkNativeBufferUsageOHOS {
VkStructureType sType;
void* pNext;
uint64_t OHOSNativeBufferUsage;
} VkNativeBufferUsageOHOS;
typedef struct VkNativeBufferPropertiesOHOS {
VkStructureType sType;
void* pNext;
VkDeviceSize allocationSize;
uint32_t memoryTypeBits;
} VkNativeBufferPropertiesOHOS;
typedef struct VkNativeBufferFormatPropertiesOHOS {
VkStructureType sType;
void* pNext;
VkFormat format;
uint64_t externalFormat;
VkFormatFeatureFlags formatFeatures;
VkComponentMapping samplerYcbcrConversionComponents;
VkSamplerYcbcrModelConversion suggestedYcbcrModel;
VkSamplerYcbcrRange suggestedYcbcrRange;
VkChromaLocation suggestedXChromaOffset;
VkChromaLocation suggestedYChromaOffset;
} VkNativeBufferFormatPropertiesOHOS;
typedef struct VkImportNativeBufferInfoOHOS {
VkStructureType sType;
const void* pNext;
struct OH_NativeBuffer* buffer;
} VkImportNativeBufferInfoOHOS;
typedef struct VkMemoryGetNativeBufferInfoOHOS {
VkStructureType sType;
const void* pNext;
VkDeviceMemory memory;
} VkMemoryGetNativeBufferInfoOHOS;
typedef struct VkExternalFormatOHOS {
VkStructureType sType;
void* pNext;
uint64_t externalFormat;
} VkExternalFormatOHOS;
typedef VkResult (VKAPI_PTR *PFN_vkGetNativeBufferPropertiesOHOS)(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties);
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryNativeBufferOHOS)(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer);
#ifndef VK_NO_PROTOTYPES
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetNativeBufferPropertiesOHOS(
VkDevice device,
const struct OH_NativeBuffer* buffer,
VkNativeBufferPropertiesOHOS* pProperties);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryNativeBufferOHOS(
VkDevice device,
const VkMemoryGetNativeBufferInfoOHOS* pInfo,
struct OH_NativeBuffer** pBuffer);
#endif
#endif
// VK_OHOS_surface is a preprocessor guard. Do not pass it to API calls.
#define VK_OHOS_surface 1
typedef struct NativeWindow OHNativeWindow;
@@ -44,6 +113,68 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS(
#endif
#endif
// VK_OHOS_native_buffer is a preprocessor guard. Do not pass it to API calls.
#define VK_OHOS_native_buffer 1
struct OHBufferHandle;
#define VK_OHOS_NATIVE_BUFFER_SPEC_VERSION 1
#define VK_OHOS_NATIVE_BUFFER_EXTENSION_NAME "VK_OHOS_native_buffer"
typedef enum VkSwapchainImageUsageFlagBitsOHOS {
VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_OHOS = 0x00000001,
VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM_OHOS = 0x7FFFFFFF
} VkSwapchainImageUsageFlagBitsOHOS;
typedef VkFlags VkSwapchainImageUsageFlagsOHOS;
typedef struct VkNativeBufferOHOS {
VkStructureType sType;
const void* pNext;
struct OHBufferHandle* handle;
} VkNativeBufferOHOS;
typedef struct VkSwapchainImageCreateInfoOHOS {
VkStructureType sType;
const void* pNext;
VkSwapchainImageUsageFlagsOHOS usage;
} VkSwapchainImageCreateInfoOHOS;
typedef struct VkPhysicalDevicePresentationPropertiesOHOS {
VkStructureType sType;
void* pNext;
VkBool32 sharedImage;
} VkPhysicalDevicePresentationPropertiesOHOS;
typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageOHOS)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, uint64_t* grallocUsage);
typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageOHOS)(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence);
typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageOHOS)(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int32_t* pNativeFenceFd);
#ifndef VK_NO_PROTOTYPES
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsageOHOS(
VkDevice device,
VkFormat format,
VkImageUsageFlags imageUsage,
uint64_t* grallocUsage);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireImageOHOS(
VkDevice device,
VkImage image,
int32_t nativeFenceFd,
VkSemaphore semaphore,
VkFence fence);
#endif
#ifndef VK_ONLY_EXPORTED_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalReleaseImageOHOS(
VkQueue queue,
uint32_t waitSemaphoreCount,
const VkSemaphore* pWaitSemaphores,
VkImage image,
int32_t* pNativeFenceFd);
#endif
#endif
#ifdef __cplusplus
}
#endif
third_party/vulkan/vulkan_raii.hpp
Vendored
+1722 -1286
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_shared.hpp
Vendored
+62 -66
View File
@@ -84,7 +84,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename DestructorType, typename Deleter>
struct SharedHeader
{
SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT
SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
: parent( std::move( parent ) )
, deleter( std::move( deleter ) )
{
@@ -97,7 +97,7 @@ namespace VULKAN_HPP_NAMESPACE
template <typename Deleter>
struct SharedHeader<NoDestructor, Deleter>
{
SharedHeader( Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
SharedHeader( Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
Deleter deleter;
};
@@ -282,9 +282,7 @@ namespace VULKAN_HPP_NAMESPACE
SharedHandle() = default;
template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value && !HasPoolType<T>::value>::type>
explicit SharedHandle( HandleType handle,
SharedHandle<DestructorTypeOf<HandleType>> parent,
DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
explicit SharedHandle( HandleType handle, SharedHandle<DestructorTypeOf<HandleType>> parent, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( parent ), std::move( deleter ) )
{
}
@@ -301,8 +299,7 @@ namespace VULKAN_HPP_NAMESPACE
}
template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
explicit SharedHandle( HandleType handle, DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( deleter ) )
explicit SharedHandle( HandleType handle, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT : BaseType( handle, std::move( deleter ) )
{
}
@@ -336,7 +333,7 @@ namespace VULKAN_HPP_NAMESPACE
using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks = nullptr,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
, m_dispatch( &dispatch )
@@ -375,7 +372,7 @@ namespace VULKAN_HPP_NAMESPACE
using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks = nullptr,
const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
: m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
, m_dispatch( &dispatch )
@@ -523,16 +520,6 @@ namespace VULKAN_HPP_NAMESPACE
using SharedSemaphore = SharedHandle<Semaphore>;
template <>
class SharedHandleTraits<Event>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Event>;
};
using SharedEvent = SharedHandle<Event>;
template <>
class SharedHandleTraits<QueryPool>
{
@@ -553,16 +540,6 @@ namespace VULKAN_HPP_NAMESPACE
using SharedBuffer = SharedHandle<Buffer>;
template <>
class SharedHandleTraits<BufferView>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<BufferView>;
};
using SharedBufferView = SharedHandle<BufferView>;
template <>
class SharedHandleTraits<Image>
{
@@ -583,6 +560,46 @@ namespace VULKAN_HPP_NAMESPACE
using SharedImageView = SharedHandle<ImageView>;
template <>
class SharedHandleTraits<CommandPool>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<CommandPool>;
};
using SharedCommandPool = SharedHandle<CommandPool>;
template <>
class SharedHandleTraits<CommandBuffer>
{
public:
using DestructorType = Device;
using deleter = detail::PoolFreeShared<CommandBuffer, CommandPool>;
};
using SharedCommandBuffer = SharedHandle<CommandBuffer>;
template <>
class SharedHandleTraits<Event>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<Event>;
};
using SharedEvent = SharedHandle<Event>;
template <>
class SharedHandleTraits<BufferView>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<BufferView>;
};
using SharedBufferView = SharedHandle<BufferView>;
template <>
class SharedHandleTraits<ShaderModule>
{
@@ -683,38 +700,7 @@ namespace VULKAN_HPP_NAMESPACE
using SharedRenderPass = SharedHandle<RenderPass>;
template <>
class SharedHandleTraits<CommandPool>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<CommandPool>;
};
using SharedCommandPool = SharedHandle<CommandPool>;
template <>
class SharedHandleTraits<CommandBuffer>
{
public:
using DestructorType = Device;
using deleter = detail::PoolFreeShared<CommandBuffer, CommandPool>;
};
using SharedCommandBuffer = SharedHandle<CommandBuffer>;
//=== VK_VERSION_1_1 ===
template <>
class SharedHandleTraits<SamplerYcbcrConversion>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
};
using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>;
template <>
class SharedHandleTraits<DescriptorUpdateTemplate>
{
@@ -726,6 +712,17 @@ namespace VULKAN_HPP_NAMESPACE
using SharedDescriptorUpdateTemplate = SharedHandle<DescriptorUpdateTemplate>;
using SharedDescriptorUpdateTemplateKHR = SharedHandle<DescriptorUpdateTemplate>;
template <>
class SharedHandleTraits<SamplerYcbcrConversion>
{
public:
using DestructorType = Device;
using deleter = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
};
using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>;
//=== VK_VERSION_1_3 ===
template <>
class SharedHandleTraits<PrivateDataSlot>
@@ -1055,7 +1052,7 @@ namespace VULKAN_HPP_NAMESPACE
struct ImageHeader : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>
{
ImageHeader( SharedHandle<DestructorTypeOf<Image>> parent,
typename SharedHandleTraits<Image>::deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<Image>::deleter() ),
typename SharedHandleTraits<Image>::deleter deleter = typename SharedHandleTraits<Image>::deleter(),
SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
: SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>( std::move( parent ), std::move( deleter ) )
, swapchainOwned( swapchainOwned )
@@ -1077,8 +1074,8 @@ namespace VULKAN_HPP_NAMESPACE
explicit SharedHandle( Image handle,
SharedHandle<DestructorTypeOf<Image>> parent,
SwapchainOwns swapchain_owned VULKAN_HPP_DEFAULT_ASSIGNMENT( SwapchainOwns::no ),
DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
SwapchainOwns swapchain_owned = SwapchainOwns::no,
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
{
}
@@ -1097,8 +1094,7 @@ namespace VULKAN_HPP_NAMESPACE
{
SwapchainHeader( SharedHandle<SurfaceKHR> surface,
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
typename SharedHandleTraits<SwapchainKHR>::deleter deleter
VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<SwapchainKHR>::deleter() ) ) VULKAN_HPP_NOEXCEPT
typename SharedHandleTraits<SwapchainKHR>::deleter deleter = typename SharedHandleTraits<SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
: surface( std::move( surface ) )
, parent( std::move( parent ) )
, deleter( std::move( deleter ) )
@@ -1123,7 +1119,7 @@ namespace VULKAN_HPP_NAMESPACE
explicit SharedHandle( SwapchainKHR handle,
SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
SharedHandle<SurfaceKHR> surface,
DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
: BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
{
}
third_party/vulkan/vulkan_static_assertions.hpp
Vendored
+1153 -992
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_structs.hpp
Vendored
+2637 -87
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_to_string.hpp
Vendored
+1374 -1203
View File
File diff suppressed because it is too large Load Diff
third_party/vulkan/vulkan_video.cppm
Vendored
-5
View File
@@ -10,11 +10,6 @@
module;
#include <vulkan/vulkan_hpp_macros.hpp>
#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
# define VULKAN_HPP_ENABLE_STD_MODULE
#endif
#include <vulkan/vulkan_video.hpp>
export module vulkan_video_hpp;