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

2
include/vk_video/vulkan_video_codec_av1std.h
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;

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;