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

Update for Vulkan-Docs 1.4.230

Browse source
This commit is contained in:
Jon Leech 2025-10-24 02:45:46 +01:00 • committed by Jon Leech
parent 33d7f51258
commit ee3b5caaa7
25 changed files with 18311 additions and 13125 deletions
Download patch file Download diff file Expand all files Collapse all files

659
include/vulkan/vulkan.cppm
View file

File diff suppressed because it is too large Load diff

3375
include/vulkan/vulkan.hpp
View file

File diff suppressed because it is too large Load diff

3963
include/vulkan/vulkan_core.h
View file

File diff suppressed because it is too large Load diff

2504
include/vulkan/vulkan_enums.hpp
View file

File diff suppressed because it is too large Load diff

264
include/vulkan/vulkan_extension_inspection.hpp
View file

@ -462,6 +462,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 +483,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",
@ -499,7 +503,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 +607,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 +707,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 +733,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 +745,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 +791,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 +827,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 +877,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 +984,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 +1022,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 +1056,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 +1070,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 +1094,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 +1182,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 +1272,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 +1389,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 +1562,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 +1578,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 +1927,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 +1994,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 +2019,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 +2067,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 +2147,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",
{ {
@ -2292,21 +2347,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 +2374,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 +2591,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 +2605,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 +2654,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 +2726,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,15 +2757,17 @@ 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",
{ {
@ -2758,7 +2829,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 +2985,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 +3490,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 +3541,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 )
@ -3671,17 +3759,20 @@ 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*/
@ -3691,7 +3782,9 @@ namespace VULKAN_HPP_NAMESPACE
|| ( 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 +3860,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 +3901,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" );

5019
include/vulkan/vulkan_funcs.hpp
View file

File diff suppressed because it is too large Load diff

2370
include/vulkan/vulkan_handles.hpp
View file

File diff suppressed because it is too large Load diff

281
include/vulkan/vulkan_hash.hpp
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>
{
@ -8428,6 +8457,21 @@ namespace std
}
};
# 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*/
template <>
struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT>
{
@ -11526,6 +11570,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 +11829,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;
}
};
@ -12607,6 +12681,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 +13240,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 +13949,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>
{
@ -16882,6 +17000,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 +17028,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 +17124,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 +18135,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>
{

62
include/vulkan/vulkan_ohos.h
View file

@ -44,6 +44,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;
const 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

2766
include/vulkan/vulkan_raii.hpp
View file

File diff suppressed because it is too large Load diff

102
include/vulkan/vulkan_shared.hpp
View file

@ -523,16 +523,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 +543,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 +563,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 +703,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 +715,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>

2068
include/vulkan/vulkan_static_assertions.hpp
View file

File diff suppressed because it is too large Load diff

1464
include/vulkan/vulkan_structs.hpp
View file

File diff suppressed because it is too large Load diff

2565
include/vulkan/vulkan_to_string.hpp
View file

File diff suppressed because it is too large Load diff

5
include/vulkan/vulkan_video.cppm
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;