updated vulkan to make use of cm2

2026-09-18 16:55:14 +02:00 · 2025-04-18 22:10:57 +08:00
parent 40adb8af35
commit 29b57d2175
99 changed files with 96968 additions and 35296 deletions
@@ -9,6 +9,8 @@

 #pragma once

+#include <stdint.h>
+
 #include <array>
 #include <functional>
 #include <mutex>
@@ -1,8 +1,8 @@
 // *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See format_utils_generator.py for modifications
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0

@@ -249,6 +249,8 @@ inline bool vkuFormatIsSinglePlane_422(VkFormat format);
 inline uint32_t vkuFormatPlaneCount(VkFormat format);

 // Returns whether a VkFormat is multiplane
+// Note - Formats like VK_FORMAT_G8B8G8R8_422_UNORM are NOT multi-planar, they require a
+//        VkSamplerYcbcrConversion and you should use vkuFormatRequiresYcbcrConversion instead
 inline bool vkuFormatIsMultiplane(VkFormat format) { return ((vkuFormatPlaneCount(format)) > 1u); }

 // Returns a VkFormat that is compatible with a given plane of a multiplane format
@@ -259,6 +261,10 @@ inline VkFormat vkuFindMultiplaneCompatibleFormat(VkFormat mp_fmt, VkImageAspect
 // Will return {1, 1} if given a plane aspect that doesn't exist for the VkFormat
 inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspectFlagBits plane_aspect);

+// From table in spec vkspec.html#formats-compatible-zs-color
+// Introduced in VK_KHR_maintenance8 to allow copying between color and depth/stencil formats
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask);
+
 // Returns the count of components in a VkFormat
 inline uint32_t vkuFormatComponentCount(VkFormat format);

@@ -268,15 +274,23 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format);
 // Returns the Compatibility Class of a VkFormat as defined by the spec
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format);

-// Return true if a VkFormat is 'normal', with one texel per format element
-inline bool vkuFormatElementIsTexel(VkFormat format);
+// Returns the number of texels inside a texel block
+// Will always be 1 when not using compressed block formats
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format);
+
+// Returns the number of bytes in a single Texel Block.
+// When dealing with a depth/stencil format, need to consider using vkuFormatStencilSize or vkuFormatDepthSize.
+// When dealing with mulit-planar formats, need to consider using vkuGetPlaneIndex.
+inline uint32_t vkuFormatTexelBlockSize(VkFormat format);

 // Return size, in bytes, of one element of a VkFormat
 // Format must not be a depth, stencil, or multiplane format
+// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
 inline uint32_t vkuFormatElementSize(VkFormat format);

 // Return the size in bytes of one texel of a VkFormat
 // For compressed or multi-plane, this may be a fractional number
+// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
 inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);

 // Return the size in bytes of one texel of a VkFormat
@@ -349,8 +363,8 @@ struct VKU_FORMAT_COMPONENT_INFO {
 // Generic information for all formats
 struct VKU_FORMAT_INFO {
    enum VKU_FORMAT_COMPATIBILITY_CLASS compatibility;
-    uint32_t block_size;  // bytes
-    uint32_t texel_per_block;
+    uint32_t texel_block_size;  // bytes
+    uint32_t texels_per_block;
    VkExtent3D block_extent;
    uint32_t component_count;
    struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
@@ -381,10 +395,10 @@ inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {
        case VK_FORMAT_A1R5G5B5_UNORM_PACK16: {
            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}}};
            return out; }
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: {
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16: {
            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}}};
            return out; }
-        case VK_FORMAT_A8_UNORM_KHR: {
+        case VK_FORMAT_A8_UNORM: {
            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_ALPHA, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
            return out; }
        case VK_FORMAT_R8_UNORM: {
@@ -1426,8 +1440,8 @@ bool vkuFormatIsUNORM(VkFormat format) {
        case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
        case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
        case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
-        case VK_FORMAT_A8_UNORM_KHR:
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16:
+        case VK_FORMAT_A8_UNORM:
        case VK_FORMAT_R8_UNORM:
        case VK_FORMAT_R8G8_UNORM:
        case VK_FORMAT_R8G8B8_UNORM:
@@ -1811,7 +1825,7 @@ bool vkuFormatIsPacked(VkFormat format) {
        case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
        case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
        case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16:
        case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
        case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
        case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
@@ -2031,24 +2045,49 @@ inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspect
    return divisors;
 }

+// TODO - This should be generated, but will need updating the spec XML and table
+// Some few case don't have an aspect mask, so might need to check both the Depth and Stencil possiblity
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask) {
+    bool valid = false;
+
+    if (aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) {
+        if (ds_format == VK_FORMAT_S8_UINT || ds_format == VK_FORMAT_D16_UNORM_S8_UINT ||
+            ds_format == VK_FORMAT_D24_UNORM_S8_UINT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R8_UINT || color_format == VK_FORMAT_R8_SINT ||
+                      color_format == VK_FORMAT_R8_UNORM || color_format == VK_FORMAT_R8_SNORM);
+        }
+    }
+
+    if (aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) {
+        if (ds_format == VK_FORMAT_D32_SFLOAT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT ||
+            ds_format == VK_FORMAT_X8_D24_UNORM_PACK32 || ds_format == VK_FORMAT_D24_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT);
+        }
+        if (ds_format == VK_FORMAT_D16_UNORM || ds_format == VK_FORMAT_D16_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R16_SFLOAT || color_format == VK_FORMAT_R16_UNORM ||
+                      color_format == VK_FORMAT_R16_SNORM  || color_format == VK_FORMAT_R16_UINT || color_format == VK_FORMAT_R16_SINT);
+        }
+    }
+
+    return valid;
+}
+
 inline uint32_t vkuFormatComponentCount(VkFormat format) { return vkuGetFormatInfo(format).component_count; }

 inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetFormatInfo(format).block_extent; }

 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format) { return vkuGetFormatInfo(format).compatibility; }

-inline bool vkuFormatElementIsTexel(VkFormat format) {
-    if (vkuFormatIsPacked(format) || vkuFormatIsCompressed(format) || vkuFormatIsSinglePlane_422(format) || vkuFormatIsMultiplane(format)) {
-        return false;
-    } else {
-        return true;
-    }
-}
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format) { return vkuGetFormatInfo(format).texels_per_block; }

+inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
+
+// Deprecated - Use vkuFormatTexelBlockSize
 inline uint32_t vkuFormatElementSize(VkFormat format) {
    return vkuFormatElementSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
 }

+// Deprecated - Use vkuFormatTexelBlockSize
 inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
    // Depth/Stencil aspect have separate helper functions
    if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
@@ -2061,7 +2100,7 @@ inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFla
        format = vkuFindMultiplaneCompatibleFormat(format, aspectMask);
    }

-    return vkuGetFormatInfo(format).block_size;
+    return vkuGetFormatInfo(format).texel_block_size;
 }

 inline double vkuFormatTexelSize(VkFormat format) {
@@ -2080,7 +2119,7 @@ inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBit

 inline bool vkuFormatIs8bit(VkFormat format) {
    switch (format) {
-        case VK_FORMAT_A8_UNORM_KHR:
+        case VK_FORMAT_A8_UNORM:
        case VK_FORMAT_R8_UNORM:
        case VK_FORMAT_R8_SNORM:
        case VK_FORMAT_R8_USCALED:
@@ -2,7 +2,7 @@
 // File: vk_platform.h
 //
 /*
-** Copyright 2014-2024 The Khronos Group Inc.
+** Copyright 2014-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_ANDROID_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_BETA_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -53,13 +53,14 @@ typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {

 // VK_AMDX_shader_enqueue is a preprocessor guard. Do not pass it to API calls.
 #define VK_AMDX_shader_enqueue 1
-#define VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION 1
+#define VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION 2
 #define VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME "VK_AMDX_shader_enqueue"
 #define VK_SHADER_INDEX_UNUSED_AMDX       (~0U)
 typedef struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           shaderEnqueue;
+    VkBool32           shaderMeshEnqueue;
 } VkPhysicalDeviceShaderEnqueueFeaturesAMDX;

 typedef struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
@@ -70,12 +71,16 @@ typedef struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
    uint32_t           maxExecutionGraphShaderPayloadSize;
    uint32_t           maxExecutionGraphShaderPayloadCount;
    uint32_t           executionGraphDispatchAddressAlignment;
+    uint32_t           maxExecutionGraphWorkgroupCount[3];
+    uint32_t           maxExecutionGraphWorkgroups;
 } VkPhysicalDeviceShaderEnqueuePropertiesAMDX;

 typedef struct VkExecutionGraphPipelineScratchSizeAMDX {
    VkStructureType    sType;
    void*              pNext;
-    VkDeviceSize       size;
+    VkDeviceSize       minSize;
+    VkDeviceSize       maxSize;
+    VkDeviceSize       sizeGranularity;
 } VkExecutionGraphPipelineScratchSizeAMDX;

 typedef struct VkExecutionGraphPipelineCreateInfoAMDX {
@@ -116,12 +121,12 @@ typedef struct VkPipelineShaderStageNodeCreateInfoAMDX {
 } VkPipelineShaderStageNodeCreateInfoAMDX;

 typedef VkResult (VKAPI_PTR *PFN_vkCreateExecutionGraphPipelinesAMDX)(VkDevice                                        device, VkPipelineCache                 pipelineCache, uint32_t                                        createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks*    pAllocator, VkPipeline*               pPipelines);
-typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineScratchSizeAMDX)(VkDevice                                        device, VkPipeline                                      executionGraph, VkExecutionGraphPipelineScratchSizeAMDX*         pSizeInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineNodeIndexAMDX)(VkDevice                                        device, VkPipeline                                      executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX*   pNodeInfo, uint32_t*                                       pNodeIndex);
-typedef void (VKAPI_PTR *PFN_vkCmdInitializeGraphScratchMemoryAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, const VkDispatchGraphCountInfoAMDX*              pCountInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, const VkDispatchGraphCountInfoAMDX*              pCountInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceAddress                                 countInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineScratchSizeAMDX)(VkDevice                                        device, VkPipeline                                      executionGraph, VkExecutionGraphPipelineScratchSizeAMDX*        pSizeInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineNodeIndexAMDX)(VkDevice                                        device, VkPipeline                                      executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX*  pNodeInfo, uint32_t*                                       pNodeIndex);
+typedef void (VKAPI_PTR *PFN_vkCmdInitializeGraphScratchMemoryAMDX)(VkCommandBuffer                                 commandBuffer, VkPipeline                                      executionGraph, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, const VkDispatchGraphCountInfoAMDX*             pCountInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, const VkDispatchGraphCountInfoAMDX*             pCountInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer                                 commandBuffer, VkDeviceAddress                                 scratch, VkDeviceSize                                    scratchSize, VkDeviceAddress                                 countInfo);

 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX(
@@ -145,21 +150,26 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX(

 VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX(
    VkCommandBuffer                             commandBuffer,
-    VkDeviceAddress                             scratch);
+    VkPipeline                                  executionGraph,
+    VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize);

 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX(
    VkCommandBuffer                             commandBuffer,
    VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize,
    const VkDispatchGraphCountInfoAMDX*         pCountInfo);

 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX(
    VkCommandBuffer                             commandBuffer,
    VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize,
    const VkDispatchGraphCountInfoAMDX*         pCountInfo);

 VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX(
    VkCommandBuffer                             commandBuffer,
    VkDeviceAddress                             scratch,
+    VkDeviceSize                                scratchSize,
    VkDeviceAddress                             countInfo);
 #endif

@@ -2,7 +2,7 @@
 #define VULKAN_DIRECTFB_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -1,4 +1,4 @@
-// Copyright 2015-2024 The Khronos Group Inc.
+// Copyright 2015-2025 The Khronos Group Inc.
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
@@ -46,7 +46,7 @@ namespace VULKAN_HPP_NAMESPACE

  VULKAN_HPP_INLINE std::map<std::string, std::string> const & getDeprecatedExtensions()
  {
-    static std::map<std::string, std::string> deprecatedExtensions = {
+    static const std::map<std::string, std::string> deprecatedExtensions = {
      { "VK_EXT_debug_report", "VK_EXT_debug_utils" },
      { "VK_NV_glsl_shader", "" },
      { "VK_NV_dedicated_allocation", "VK_KHR_dedicated_allocation" },
@@ -76,7 +76,7 @@ namespace VULKAN_HPP_NAMESPACE

  VULKAN_HPP_INLINE std::set<std::string> const & getDeviceExtensions()
  {
-    static std::set<std::string> deviceExtensions = {
+    static const std::set<std::string> deviceExtensions = {
      "VK_KHR_swapchain",
      "VK_KHR_display_swapchain",
      "VK_NV_glsl_shader",
@@ -346,6 +346,7 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_EXT_depth_clip_control",
      "VK_EXT_primitive_topology_list_restart",
      "VK_KHR_format_feature_flags2",
+      "VK_EXT_present_mode_fifo_latest_ready",
 #if defined( VK_USE_PLATFORM_FUCHSIA )
      "VK_FUCHSIA_external_memory",
      "VK_FUCHSIA_external_semaphore",
@@ -387,6 +388,7 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_NV_copy_memory_indirect",
      "VK_NV_memory_decompression",
      "VK_NV_device_generated_commands_compute",
+      "VK_NV_ray_tracing_linear_swept_spheres",
      "VK_NV_linear_color_attachment",
      "VK_KHR_shader_maximal_reconvergence",
      "VK_EXT_image_compression_control_swapchain",
@@ -412,6 +414,7 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_SEC_amigo_profiling",
      "VK_QCOM_multiview_per_view_viewports",
      "VK_NV_ray_tracing_invocation_reorder",
+      "VK_NV_cooperative_vector",
      "VK_NV_extended_sparse_address_space",
      "VK_EXT_mutable_descriptor_type",
      "VK_EXT_legacy_vertex_attributes",
@@ -423,6 +426,7 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_QCOM_multiview_per_view_render_areas",
      "VK_KHR_compute_shader_derivatives",
      "VK_KHR_video_decode_av1",
+      "VK_KHR_video_encode_av1",
      "VK_KHR_video_maintenance1",
      "VK_NV_per_stage_descriptor_set",
      "VK_QCOM_image_processing2",
@@ -443,6 +447,7 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_KHR_shader_expect_assume",
      "VK_KHR_maintenance6",
      "VK_NV_descriptor_pool_overallocation",
+      "VK_KHR_video_encode_quantization_map",
      "VK_NV_raw_access_chains",
      "VK_KHR_shader_relaxed_extended_instruction",
      "VK_NV_command_buffer_inheritance",
@@ -450,16 +455,31 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_NV_shader_atomic_float16_vector",
      "VK_EXT_shader_replicated_composites",
      "VK_NV_ray_tracing_validation",
+      "VK_NV_cluster_acceleration_structure",
+      "VK_NV_partitioned_acceleration_structure",
      "VK_EXT_device_generated_commands",
+      "VK_KHR_maintenance8",
      "VK_MESA_image_alignment_control",
-      "VK_EXT_depth_clamp_control"
+      "VK_EXT_depth_clamp_control",
+      "VK_KHR_video_maintenance2",
+      "VK_HUAWEI_hdr_vivid",
+      "VK_NV_cooperative_matrix2",
+      "VK_ARM_pipeline_opacity_micromap",
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+      "VK_EXT_external_memory_metal",
+#endif /*VK_USE_PLATFORM_METAL_EXT*/
+      "VK_KHR_depth_clamp_zero_one",
+      "VK_EXT_vertex_attribute_robustness",
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+      "VK_NV_present_metering"
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
    };
    return deviceExtensions;
  }

  VULKAN_HPP_INLINE std::set<std::string> const & getInstanceExtensions()
  {
-    static std::set<std::string> instanceExtensions = {
+    static const std::set<std::string> instanceExtensions = {
      "VK_KHR_surface",
      "VK_KHR_display",
 #if defined( VK_USE_PLATFORM_XLIB_KHR )
@@ -526,15 +546,16 @@ namespace VULKAN_HPP_NAMESPACE
      "VK_KHR_portability_enumeration",
      "VK_GOOGLE_surfaceless_query",
      "VK_LUNARG_direct_driver_loading",
-      "VK_EXT_layer_settings"
+      "VK_EXT_layer_settings",
+      "VK_NV_display_stereo"
    };
    return instanceExtensions;
  }

  VULKAN_HPP_INLINE std::map<std::string, std::vector<std::vector<std::string>>> const & getExtensionDepends( std::string const & extension )
  {
-    static std::map<std::string, std::vector<std::vector<std::string>>>                        noDependencies;
-    static std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> dependencies = {
+    static const std::map<std::string, std::vector<std::vector<std::string>>>                        noDependencies;
+    static const std::map<std::string, std::map<std::string, std::vector<std::vector<std::string>>>> dependencies = {
      { "VK_KHR_swapchain",
        { { "VK_VERSION_1_0",
            { {
@@ -992,17 +1013,15 @@ namespace VULKAN_HPP_NAMESPACE
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
      { "VK_AMDX_shader_enqueue",
        { { "VK_VERSION_1_0",
-            { {
-              "VK_KHR_get_physical_device_properties2",
-            } } },
-          { "VK_VERSION_1_1",
            { {
              "VK_KHR_synchronization2",
+              "VK_KHR_spirv_1_4",
+              "VK_EXT_extended_dynamic_state",
            } } },
          { "VK_VERSION_1_3",
            { {
+              "VK_KHR_maintenance5",
              "VK_KHR_pipeline_library",
-              "VK_KHR_spirv_1_4",
            } } } } },
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
      { "VK_EXT_inline_uniform_block",
@@ -1038,12 +1057,18 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_spirv_1_4",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
              "VK_KHR_acceleration_structure",
            } } } } },
      { "VK_KHR_ray_query",
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_spirv_1_4",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
              "VK_KHR_acceleration_structure",
            } } } } },
      { "VK_NV_shader_sm_builtins", { { "VK_VERSION_1_1", { {} } } } },
@@ -1346,6 +1371,9 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_1",
            { {
              "VK_KHR_vulkan_memory_model",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
              "VK_KHR_shader_maximal_reconvergence",
            } } } } },
      { "VK_KHR_spirv_1_4",
@@ -1512,7 +1540,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_map_memory2",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_4", { {} } } } },
      { "VK_EXT_shader_atomic_float2",
        { { "VK_VERSION_1_0",
            { {
@@ -1697,7 +1726,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_spirv_1_4",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_2", { {} } } } },
      { "VK_EXT_ycbcr_2plane_444_formats",
        { { "VK_VERSION_1_0",
            { {
@@ -1827,6 +1857,11 @@ namespace VULKAN_HPP_NAMESPACE
              "VK_KHR_get_physical_device_properties2",
            } } },
          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_present_mode_fifo_latest_ready",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_swapchain",
+            } } } } },
 #if defined( VK_USE_PLATFORM_FUCHSIA )
      { "VK_FUCHSIA_external_memory",
        { { "VK_VERSION_1_0",
@@ -2047,6 +2082,11 @@ namespace VULKAN_HPP_NAMESPACE
            { {
              "VK_NV_device_generated_commands",
            } } } } },
+      { "VK_NV_ray_tracing_linear_swept_spheres",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_ray_tracing_pipeline",
+            } } } } },
      { "VK_NV_linear_color_attachment",
        { { "VK_VERSION_1_0",
            { {
@@ -2165,7 +2205,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_maintenance5",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_4", { {} } } } },
      { "VK_QCOM_tile_properties",
        { { "VK_VERSION_1_0",
            { {
@@ -2193,7 +2234,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_maintenance3",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
      { "VK_EXT_legacy_vertex_attributes",
        { { "VK_VERSION_1_0",
            { {
@@ -2237,12 +2279,18 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
      { "VK_KHR_video_decode_av1",
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_video_decode_queue",
            } } } } },
+      { "VK_KHR_video_encode_av1",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_video_encode_queue",
+            } } } } },
      { "VK_KHR_video_maintenance1",
        { { "VK_VERSION_1_0",
            { {
@@ -2252,7 +2300,8 @@ namespace VULKAN_HPP_NAMESPACE
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_maintenance6",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_4", { {} } } } },
      { "VK_QCOM_image_processing2",
        { { "VK_VERSION_1_0",
            { {
@@ -2338,13 +2387,41 @@ namespace VULKAN_HPP_NAMESPACE
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } },
      { "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_display_stereo",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_display",
+              "VK_KHR_get_display_properties2",
+            } } } } },
+      { "VK_KHR_video_encode_quantization_map",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_video_encode_queue",
+              "VK_KHR_format_feature_flags2",
+            } } },
+          { "VK_VERSION_1_3", { {} } } } },
      { "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_cluster_acceleration_structure",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_acceleration_structure",
+            } } } } },
+      { "VK_NV_partitioned_acceleration_structure",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_acceleration_structure",
+            } } } } },
      { "VK_EXT_device_generated_commands",
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_buffer_device_address",
+            } } },
+          { "VK_VERSION_1_2",
+            { {
              "VK_KHR_maintenance5",
-            } } } } },
+            } } },
+          { "VK_VERSION_1_3", { {} } } } },
+      { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } },
      { "VK_MESA_image_alignment_control",
        { { "VK_VERSION_1_0",
            { {
@@ -2352,6 +2429,51 @@ namespace VULKAN_HPP_NAMESPACE
            } } },
          { "VK_VERSION_1_1", { {} } } } },
      { "VK_EXT_depth_clamp_control",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_video_maintenance2",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_video_queue",
+            } } } } },
+      { "VK_HUAWEI_hdr_vivid",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1",
+            { {
+              "VK_KHR_swapchain",
+              "VK_EXT_hdr_metadata",
+            } } } } },
+      { "VK_NV_cooperative_matrix2",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_cooperative_matrix",
+            } } } } },
+      { "VK_ARM_pipeline_opacity_micromap",
+        { { "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", { {} } } } },
+#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_EXT_vertex_attribute_robustness",
        { { "VK_VERSION_1_0",
            { {
              "VK_KHR_get_physical_device_properties2",
@@ -2366,7 +2488,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                                                                        std::string const & extension )
  {
 #if !defined( NDEBUG )
-    static std::set<std::string> versions = { "VK_VERSION_1_0", "VK_VERSION_1_1", "VK_VERSION_1_2", "VK_VERSION_1_3" };
+    static std::set<std::string> versions = { "VK_VERSION_1_0", "VK_VERSION_1_1", "VK_VERSION_1_2", "VK_VERSION_1_3", "VK_VERSION_1_4" };
    assert( versions.find( version ) != versions.end() );
 #endif
    static std::vector<std::vector<std::string>> noDependencies;
@@ -2393,13 +2515,13 @@ namespace VULKAN_HPP_NAMESPACE

  VULKAN_HPP_INLINE std::map<std::string, std::string> const & getObsoletedExtensions()
  {
-    static std::map<std::string, std::string> obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } };
+    static const std::map<std::string, std::string> obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } };
    return obsoletedExtensions;
  }

  VULKAN_HPP_INLINE std::map<std::string, std::string> const & getPromotedExtensions()
  {
-    static std::map<std::string, std::string> promotedExtensions = {
+    static const std::map<std::string, std::string> promotedExtensions = {
      { "VK_KHR_sampler_mirror_clamp_to_edge", "VK_VERSION_1_2" },
      { "VK_EXT_debug_marker", "VK_EXT_debug_utils" },
      { "VK_AMD_draw_indirect_count", "VK_KHR_draw_indirect_count" },
@@ -2412,12 +2534,14 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_device_group", "VK_VERSION_1_1" },
      { "VK_KHR_shader_draw_parameters", "VK_VERSION_1_1" },
      { "VK_EXT_texture_compression_astc_hdr", "VK_VERSION_1_3" },
+      { "VK_EXT_pipeline_robustness", "VK_VERSION_1_4" },
      { "VK_KHR_maintenance1", "VK_VERSION_1_1" },
      { "VK_KHR_device_group_creation", "VK_VERSION_1_1" },
      { "VK_KHR_external_memory_capabilities", "VK_VERSION_1_1" },
      { "VK_KHR_external_memory", "VK_VERSION_1_1" },
      { "VK_KHR_external_semaphore_capabilities", "VK_VERSION_1_1" },
      { "VK_KHR_external_semaphore", "VK_VERSION_1_1" },
+      { "VK_KHR_push_descriptor", "VK_VERSION_1_4" },
      { "VK_KHR_shader_float16_int8", "VK_VERSION_1_2" },
      { "VK_KHR_16bit_storage", "VK_VERSION_1_1" },
      { "VK_KHR_descriptor_update_template", "VK_VERSION_1_1" },
@@ -2445,6 +2569,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_8bit_storage", "VK_VERSION_1_2" },
      { "VK_KHR_shader_atomic_int64", "VK_VERSION_1_2" },
      { "VK_EXT_calibrated_timestamps", "VK_KHR_calibrated_timestamps" },
+      { "VK_KHR_global_priority", "VK_VERSION_1_4" },
      { "VK_EXT_vertex_attribute_divisor", "VK_KHR_vertex_attribute_divisor" },
      { "VK_EXT_pipeline_creation_feedback", "VK_VERSION_1_3" },
      { "VK_KHR_driver_properties", "VK_VERSION_1_2" },
@@ -2457,6 +2582,7 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_KHR_shader_terminate_invocation", "VK_VERSION_1_3" },
      { "VK_EXT_scalar_block_layout", "VK_VERSION_1_2" },
      { "VK_EXT_subgroup_size_control", "VK_VERSION_1_3" },
+      { "VK_KHR_dynamic_rendering_local_read", "VK_VERSION_1_4" },
      { "VK_KHR_spirv_1_4", "VK_VERSION_1_2" },
      { "VK_KHR_separate_depth_stencil_layouts", "VK_VERSION_1_2" },
      { "VK_EXT_tooling_info", "VK_VERSION_1_3" },
@@ -2467,6 +2593,8 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_host_query_reset", "VK_VERSION_1_2" },
      { "VK_EXT_index_type_uint8", "VK_KHR_index_type_uint8" },
      { "VK_EXT_extended_dynamic_state", "VK_VERSION_1_3" },
+      { "VK_EXT_host_image_copy", "VK_VERSION_1_4" },
+      { "VK_KHR_map_memory2", "VK_VERSION_1_4" },
      { "VK_EXT_shader_demote_to_helper_invocation", "VK_VERSION_1_3" },
      { "VK_KHR_shader_integer_dot_product", "VK_VERSION_1_3" },
      { "VK_EXT_texel_buffer_alignment", "VK_VERSION_1_3" },
@@ -2485,7 +2613,18 @@ namespace VULKAN_HPP_NAMESPACE
      { "VK_EXT_extended_dynamic_state2", "VK_VERSION_1_3" },
      { "VK_EXT_global_priority_query", "VK_KHR_global_priority" },
      { "VK_EXT_load_store_op_none", "VK_KHR_load_store_op_none" },
-      { "VK_KHR_maintenance4", "VK_VERSION_1_3" }
+      { "VK_KHR_maintenance4", "VK_VERSION_1_3" },
+      { "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" },
+      { "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" },
+      { "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" },
+      { "VK_KHR_load_store_op_none", "VK_VERSION_1_4" },
+      { "VK_KHR_shader_float_controls2", "VK_VERSION_1_4" },
+      { "VK_KHR_index_type_uint8", "VK_VERSION_1_4" },
+      { "VK_KHR_line_rasterization", "VK_VERSION_1_4" },
+      { "VK_KHR_shader_expect_assume", "VK_VERSION_1_4" },
+      { "VK_KHR_maintenance6", "VK_VERSION_1_4" }
    };
    return promotedExtensions;
  }
@@ -2622,6 +2761,10 @@ namespace VULKAN_HPP_NAMESPACE
    {
      return "VK_VERSION_1_3";
    }
+    if ( extension == "VK_EXT_pipeline_robustness" )
+    {
+      return "VK_VERSION_1_4";
+    }
    if ( extension == "VK_KHR_maintenance1" )
    {
      return "VK_VERSION_1_1";
@@ -2646,6 +2789,10 @@ namespace VULKAN_HPP_NAMESPACE
    {
      return "VK_VERSION_1_1";
    }
+    if ( extension == "VK_KHR_push_descriptor" )
+    {
+      return "VK_VERSION_1_4";
+    }
    if ( extension == "VK_KHR_shader_float16_int8" )
    {
      return "VK_VERSION_1_2";
@@ -2754,6 +2901,10 @@ namespace VULKAN_HPP_NAMESPACE
    {
      return "VK_KHR_calibrated_timestamps";
    }
+    if ( extension == "VK_KHR_global_priority" )
+    {
+      return "VK_VERSION_1_4";
+    }
    if ( extension == "VK_EXT_vertex_attribute_divisor" )
    {
      return "VK_KHR_vertex_attribute_divisor";
@@ -2802,6 +2953,10 @@ namespace VULKAN_HPP_NAMESPACE
    {
      return "VK_VERSION_1_3";
    }
+    if ( extension == "VK_KHR_dynamic_rendering_local_read" )
+    {
+      return "VK_VERSION_1_4";
+    }
    if ( extension == "VK_KHR_spirv_1_4" )
    {
      return "VK_VERSION_1_2";
@@ -2842,6 +2997,14 @@ namespace VULKAN_HPP_NAMESPACE
    {
      return "VK_VERSION_1_3";
    }
+    if ( extension == "VK_EXT_host_image_copy" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_map_memory2" )
+    {
+      return "VK_VERSION_1_4";
+    }
    if ( extension == "VK_EXT_shader_demote_to_helper_invocation" )
    {
      return "VK_VERSION_1_3";
@@ -2918,6 +3081,50 @@ namespace VULKAN_HPP_NAMESPACE
    {
      return "VK_VERSION_1_3";
    }
+    if ( extension == "VK_KHR_shader_subgroup_rotate" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_EXT_depth_clamp_zero_one" )
+    {
+      return "VK_KHR_depth_clamp_zero_one";
+    }
+    if ( extension == "VK_EXT_pipeline_protected_access" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_maintenance5" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_vertex_attribute_divisor" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_load_store_op_none" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_shader_float_controls2" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_index_type_uint8" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_line_rasterization" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_shader_expect_assume" )
+    {
+      return "VK_VERSION_1_4";
+    }
+    if ( extension == "VK_KHR_maintenance6" )
+    {
+      return "VK_VERSION_1_4";
+    }
    return "";
  }

@@ -3081,7 +3288,7 @@ namespace VULKAN_HPP_NAMESPACE
        || ( extension == "VK_VALVE_mutable_descriptor_type" ) || ( extension == "VK_EXT_vertex_input_dynamic_state" ) ||
           ( extension == "VK_EXT_physical_device_drm" ) || ( extension == "VK_EXT_device_address_binding_report" ) ||
           ( extension == "VK_EXT_depth_clip_control" ) || ( extension == "VK_EXT_primitive_topology_list_restart" ) ||
-           ( extension == "VK_KHR_format_feature_flags2" )
+           ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" )
 #if defined( VK_USE_PLATFORM_FUCHSIA )
        || ( extension == "VK_FUCHSIA_external_memory" ) || ( extension == "VK_FUCHSIA_external_semaphore" ) || ( extension == "VK_FUCHSIA_buffer_collection" )
 #endif /*VK_USE_PLATFORM_FUCHSIA*/
@@ -3103,24 +3310,26 @@ namespace VULKAN_HPP_NAMESPACE
           ( extension == "VK_EXT_non_seamless_cube_map" ) || ( extension == "VK_ARM_render_pass_striped" ) ||
           ( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_NV_copy_memory_indirect" ) ||
           ( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_NV_device_generated_commands_compute" ) ||
-           ( 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_EXT_subpass_merge_feedback" ) ||
-           ( 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" )
+           ( 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_EXT_subpass_merge_feedback" ) || ( 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" )
 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
        || ( extension == "VK_ANDROID_external_format_resolve" )
 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
        || ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) ||
           ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) ||
           ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_QCOM_multiview_per_view_viewports" ) ||
-           ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_extended_sparse_address_space" ) ||
-           ( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) ||
-           ( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) ||
-           ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_NV_low_latency2" ) ||
-           ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_QCOM_multiview_per_view_render_areas" ) ||
-           ( extension == "VK_KHR_compute_shader_derivatives" ) || ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_maintenance1" ) ||
+           ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_NV_cooperative_vector" ) ||
+           ( extension == "VK_NV_extended_sparse_address_space" ) || ( extension == "VK_EXT_mutable_descriptor_type" ) ||
+           ( extension == "VK_EXT_legacy_vertex_attributes" ) || ( extension == "VK_ARM_shader_core_builtins" ) ||
+           ( extension == "VK_EXT_pipeline_library_group_handles" ) || ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) ||
+           ( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) ||
+           ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_compute_shader_derivatives" ) ||
+           ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) || ( extension == "VK_KHR_video_maintenance1" ) ||
           ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) ||
           ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) ||
           ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) ||
@@ -3130,12 +3339,23 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
        || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) ||
           ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) ||
-           ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_NV_raw_access_chains" ) ||
-           ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) ||
-           ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) ||
-           ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) ||
-           ( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_MESA_image_alignment_control" ) ||
-           ( extension == "VK_EXT_depth_clamp_control" );
+           ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) ||
+           ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) ||
+           ( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) ||
+           ( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) ||
+           ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) ||
+           ( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) ||
+           ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) ||
+           ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) ||
+           ( extension == "VK_ARM_pipeline_opacity_micromap" )
+#if defined( VK_USE_PLATFORM_METAL_EXT )
+        || ( 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" )
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+        || ( extension == "VK_NV_present_metering" )
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      ;
  }

  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )
@@ -3195,7 +3415,7 @@ namespace VULKAN_HPP_NAMESPACE
        || ( extension == "VK_QNX_screen_surface" )
 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
        || ( extension == "VK_KHR_portability_enumeration" ) || ( extension == "VK_GOOGLE_surfaceless_query" ) ||
-           ( extension == "VK_LUNARG_direct_driver_loading" ) || ( extension == "VK_EXT_layer_settings" );
+           ( extension == "VK_LUNARG_direct_driver_loading" ) || ( extension == "VK_EXT_layer_settings" ) || ( extension == "VK_NV_display_stereo" );
  }

  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension )
@@ -3212,30 +3432,31 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
           ( 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_KHR_maintenance1" ) || ( extension == "VK_KHR_device_group_creation" ) ||
+           ( 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" ) ||
           ( extension == "VK_KHR_external_semaphore_capabilities" ) || ( extension == "VK_KHR_external_semaphore" ) ||
-           ( extension == "VK_KHR_shader_float16_int8" ) || ( extension == "VK_KHR_16bit_storage" ) || ( extension == "VK_KHR_descriptor_update_template" ) ||
-           ( extension == "VK_KHR_imageless_framebuffer" ) || ( extension == "VK_KHR_create_renderpass2" ) ||
-           ( extension == "VK_KHR_external_fence_capabilities" ) || ( extension == "VK_KHR_external_fence" ) || ( extension == "VK_KHR_maintenance2" ) ||
-           ( extension == "VK_KHR_variable_pointers" ) || ( extension == "VK_KHR_dedicated_allocation" ) || ( extension == "VK_EXT_sampler_filter_minmax" ) ||
-           ( extension == "VK_KHR_storage_buffer_storage_class" ) || ( extension == "VK_EXT_inline_uniform_block" ) ||
-           ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) ||
-           ( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_KHR_sampler_ycbcr_conversion" ) || ( extension == "VK_KHR_bind_memory2" ) ||
-           ( extension == "VK_EXT_descriptor_indexing" ) || ( extension == "VK_EXT_shader_viewport_index_layer" ) || ( extension == "VK_KHR_maintenance3" ) ||
-           ( extension == "VK_KHR_draw_indirect_count" ) || ( extension == "VK_EXT_global_priority" ) ||
-           ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) ||
-           ( extension == "VK_KHR_shader_atomic_int64" ) || ( extension == "VK_EXT_calibrated_timestamps" ) ||
+           ( extension == "VK_KHR_push_descriptor" ) || ( extension == "VK_KHR_shader_float16_int8" ) || ( extension == "VK_KHR_16bit_storage" ) ||
+           ( extension == "VK_KHR_descriptor_update_template" ) || ( extension == "VK_KHR_imageless_framebuffer" ) ||
+           ( extension == "VK_KHR_create_renderpass2" ) || ( extension == "VK_KHR_external_fence_capabilities" ) || ( extension == "VK_KHR_external_fence" ) ||
+           ( extension == "VK_KHR_maintenance2" ) || ( extension == "VK_KHR_variable_pointers" ) || ( extension == "VK_KHR_dedicated_allocation" ) ||
+           ( extension == "VK_EXT_sampler_filter_minmax" ) || ( extension == "VK_KHR_storage_buffer_storage_class" ) ||
+           ( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_KHR_relaxed_block_layout" ) ||
+           ( extension == "VK_KHR_get_memory_requirements2" ) || ( extension == "VK_KHR_image_format_list" ) ||
+           ( extension == "VK_KHR_sampler_ycbcr_conversion" ) || ( extension == "VK_KHR_bind_memory2" ) || ( extension == "VK_EXT_descriptor_indexing" ) ||
+           ( extension == "VK_EXT_shader_viewport_index_layer" ) || ( extension == "VK_KHR_maintenance3" ) || ( extension == "VK_KHR_draw_indirect_count" ) ||
+           ( extension == "VK_EXT_global_priority" ) || ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) ||
+           ( extension == "VK_KHR_shader_atomic_int64" ) || ( extension == "VK_EXT_calibrated_timestamps" ) || ( extension == "VK_KHR_global_priority" ) ||
           ( extension == "VK_EXT_vertex_attribute_divisor" ) || ( extension == "VK_EXT_pipeline_creation_feedback" ) ||
           ( extension == "VK_KHR_driver_properties" ) || ( extension == "VK_KHR_shader_float_controls" ) || ( extension == "VK_KHR_depth_stencil_resolve" ) ||
           ( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_fragment_shader_barycentric" ) ||
           ( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_KHR_vulkan_memory_model" ) ||
           ( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_scalar_block_layout" ) ||
-           ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_KHR_separate_depth_stencil_layouts" ) ||
-           ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) ||
-           ( extension == "VK_KHR_uniform_buffer_standard_layout" ) || ( extension == "VK_KHR_buffer_device_address" ) ||
-           ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_index_type_uint8" ) ||
-           ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
+           ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_KHR_spirv_1_4" ) ||
+           ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_tooling_info" ) ||
+           ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_uniform_buffer_standard_layout" ) ||
+           ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) ||
+           ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_host_image_copy" ) ||
+           ( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) ||
           ( extension == "VK_KHR_shader_integer_dot_product" ) || ( extension == "VK_EXT_texel_buffer_alignment" ) ||
           ( extension == "VK_KHR_shader_non_semantic_info" ) || ( extension == "VK_EXT_private_data" ) ||
           ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) ||
@@ -3243,7 +3464,12 @@ namespace VULKAN_HPP_NAMESPACE
           ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) ||
           ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_VALVE_mutable_descriptor_type" ) ||
           ( extension == "VK_KHR_format_feature_flags2" ) || ( 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_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_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" );
  }
 }  // namespace VULKAN_HPP_NAMESPACE

@@ -1,4 +1,4 @@
-// Copyright 2015-2024 The Khronos Group Inc.
+// Copyright 2015-2025 The Khronos Group Inc.
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
@@ -354,6 +354,8 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x10SfloatBlock: return 16;
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x10SfloatBlock: return 16;
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x12SfloatBlock: return 16;
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return 2;
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm: return 1;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG: return 8;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppUnormBlockIMG: return 8;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppUnormBlockIMG: return 8;
@@ -363,8 +365,6 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 8;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 8;
      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 4;
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 2;
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;

      default: VULKAN_HPP_ASSERT( false ); return 0;
    }
@@ -613,6 +613,8 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x10SfloatBlock: return "ASTC_10x10";
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x10SfloatBlock: return "ASTC_12x10";
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x12SfloatBlock: return "ASTC_12x12";
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return "16-bit";
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm: return "8-bit alpha";
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG: return "PVRTC1_2BPP";
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppUnormBlockIMG: return "PVRTC1_4BPP";
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppUnormBlockIMG: return "PVRTC2_2BPP";
@@ -622,8 +624,6 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return "PVRTC2_2BPP";
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return "PVRTC2_4BPP";
      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return "32-bit";
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return "16-bit";
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return "8-bit alpha";

      default: VULKAN_HPP_ASSERT( false ); return "";
    }
@@ -2005,14 +2005,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 3: return 4;
          default: VULKAN_HPP_ASSERT( false ); return 0;
        }
-      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
-        switch ( component )
-        {
-          case 0: return 16;
-          case 1: return 16;
-          default: VULKAN_HPP_ASSERT( false ); return 0;
-        }
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16:
        switch ( component )
        {
          case 0: return 1;
@@ -2021,12 +2014,19 @@ namespace VULKAN_HPP_NAMESPACE
          case 3: return 5;
          default: VULKAN_HPP_ASSERT( false ); return 0;
        }
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR:
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm:
        switch ( component )
        {
          case 0: return 8;
          default: VULKAN_HPP_ASSERT( false ); return 0;
        }
+      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
+        switch ( component )
+        {
+          case 0: return 16;
+          case 1: return 16;
+          default: VULKAN_HPP_ASSERT( false ); return 0;
+        }

      default: return 0;
    }
@@ -2275,6 +2275,8 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x10SfloatBlock: return 4;
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x10SfloatBlock: return 4;
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x12SfloatBlock: return 4;
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return 4;
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm: return 1;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG: return 4;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppUnormBlockIMG: return 4;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppUnormBlockIMG: return 4;
@@ -2284,8 +2286,6 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 4;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 4;
      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 2;
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 4;
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;

      default: return 0;
    }
@@ -4227,6 +4227,21 @@ namespace VULKAN_HPP_NAMESPACE
          case 3: return "A";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16:
+        switch ( component )
+        {
+          case 0: return "A";
+          case 1: return "B";
+          case 2: return "G";
+          case 3: return "R";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm:
+        switch ( component )
+        {
+          case 0: return "A";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG:
        switch ( component )
        {
@@ -4306,21 +4321,6 @@ namespace VULKAN_HPP_NAMESPACE
          case 1: return "G";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
-        switch ( component )
-        {
-          case 0: return "A";
-          case 1: return "B";
-          case 2: return "G";
-          case 3: return "R";
-          default: VULKAN_HPP_ASSERT( false ); return "";
-        }
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR:
-        switch ( component )
-        {
-          case 0: return "A";
-          default: VULKAN_HPP_ASSERT( false ); return "";
-        }

      default: return "";
    }
@@ -6262,6 +6262,21 @@ namespace VULKAN_HPP_NAMESPACE
          case 3: return "SFLOAT";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16:
+        switch ( component )
+        {
+          case 0: return "UNORM";
+          case 1: return "UNORM";
+          case 2: return "UNORM";
+          case 3: return "UNORM";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm:
+        switch ( component )
+        {
+          case 0: return "UNORM";
+          default: VULKAN_HPP_ASSERT( false ); return "";
+        }
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG:
        switch ( component )
        {
@@ -6341,21 +6356,6 @@ namespace VULKAN_HPP_NAMESPACE
          case 1: return "SFIXED5";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR:
-        switch ( component )
-        {
-          case 0: return "UNORM";
-          case 1: return "UNORM";
-          case 2: return "UNORM";
-          case 3: return "UNORM";
-          default: VULKAN_HPP_ASSERT( false ); return "";
-        }
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR:
-        switch ( component )
-        {
-          case 0: return "UNORM";
-          default: VULKAN_HPP_ASSERT( false ); return "";
-        }

      default: return "";
    }
@@ -6796,7 +6796,7 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: return 16;
      case VULKAN_HPP_NAMESPACE::Format::eA4R4G4B4UnormPack16: return 16;
      case VULKAN_HPP_NAMESPACE::Format::eA4B4G4R4UnormPack16: return 16;
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 16;
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return 16;

      default: return 0;
    }
@@ -7649,6 +7649,8 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x10SfloatBlock: return 100;
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x10SfloatBlock: return 120;
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x12SfloatBlock: return 144;
+      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16: return 1;
+      case VULKAN_HPP_NAMESPACE::Format::eA8Unorm: return 1;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc12BppUnormBlockIMG: return 1;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppUnormBlockIMG: return 1;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppUnormBlockIMG: return 1;
@@ -7658,8 +7660,6 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: return 1;
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: return 1;
      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: return 1;
-      case VULKAN_HPP_NAMESPACE::Format::eA1B5G5R5UnormPack16KHR: return 1;
-      case VULKAN_HPP_NAMESPACE::Format::eA8UnormKHR: return 1;

      default: VULKAN_HPP_ASSERT( false ); return 0;
    }
@@ -2,7 +2,7 @@
 #define VULKAN_FUCHSIA_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_GGP_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -1,4 +1,4 @@
-// Copyright 2015-2024 The Khronos Group Inc.
+// Copyright 2015-2025 The Khronos Group Inc.
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
@@ -257,33 +257,40 @@

 namespace VULKAN_HPP_NAMESPACE
 {
-  class DispatchLoaderDynamic;
+  namespace detail
+  {
+    class DispatchLoaderDynamic;
+
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
+#  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+    extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
+#  endif
+#endif
+  }  // namespace detail
 }  // namespace VULKAN_HPP_NAMESPACE

 #if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
 #  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
-#    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE                                             \
-      namespace VULKAN_HPP_NAMESPACE                                                                       \
-      {                                                                                                    \
-        VULKAN_HPP_STORAGE_API ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
+#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic
+#    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE                       \
+      namespace VULKAN_HPP_NAMESPACE                                                 \
+      {                                                                              \
+        namespace detail                                                             \
+        {                                                                            \
+          VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
+        }                                                                            \
      }
-
-namespace VULKAN_HPP_NAMESPACE
-{
-  extern VULKAN_HPP_STORAGE_API VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic defaultDispatchLoaderDynamic;
-}  // namespace VULKAN_HPP_NAMESPACE
 #  else
-#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
+#    define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic()
 #    define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
 #  endif
 #endif

 #if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
 #  if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
+#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic
 #  else
-#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
+#    define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic
 #  endif
 #endif

@@ -2,7 +2,7 @@
 #define VULKAN_IOS_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_MACOS_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_METAL_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -188,6 +188,47 @@ VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(
    VkExportMetalObjectsInfoEXT*                pMetalObjectsInfo);
 #endif

+
+// VK_EXT_external_memory_metal is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_external_memory_metal 1
+#define VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION 1
+#define VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME "VK_EXT_external_memory_metal"
+typedef struct VkImportMemoryMetalHandleInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    void*                                 handle;
+} VkImportMemoryMetalHandleInfoEXT;
+
+typedef struct VkMemoryMetalHandlePropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryMetalHandlePropertiesEXT;
+
+typedef struct VkMemoryGetMetalHandleInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetMetalHandleInfoEXT;
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(
+    VkDevice                                    device,
+    const VkMemoryGetMetalHandleInfoEXT*        pGetMetalHandleInfo,
+    void**                                      pHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    const void*                                 pHandle,
+    VkMemoryMetalHandlePropertiesEXT*           pMemoryMetalHandleProperties);
+#endif
+
 #ifdef __cplusplus
 }
 #endif
@@ -2,7 +2,7 @@
 #define VULKAN_SCREEN_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -1,4 +1,4 @@
-// Copyright 2015-2024 The Khronos Group Inc.
+// Copyright 2015-2025 The Khronos Group Inc.
 //
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //
@@ -308,159 +308,166 @@ namespace VULKAN_HPP_NAMESPACE
    using BaseType::internalDestroy;
  };

-  template <typename HandleType>
-  class SharedHandleTraits;
+  namespace detail
+  {

 // Silence the function cast warnings.
 #  if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
 #    pragma GCC diagnostic push
 #    pragma GCC diagnostic ignored "-Wcast-function-type"
+#  elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wcast-function-type"
 #  endif

-  template <typename HandleType>
-  class ObjectDestroyShared
-  {
-  public:
-    using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
-
-    template <class Dispatcher>
-    using DestroyFunctionPointerType =
-      typename std::conditional<HasDestructor<HandleType>::value,
-                                void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
-                                void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
-
-    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,
-                         const Dispatcher & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-      : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
-      , m_dispatch( &dispatch )
-      , m_allocationCallbacks( allocationCallbacks )
+    template <typename HandleType>
+    class ObjectDestroyShared
    {
-    }
+    public:
+      using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;

-  public:
-    template <typename T = HandleType>
-    typename std::enable_if<HasDestructor<T>::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
+      template <class Dispatcher>
+      using DestroyFunctionPointerType =
+        typename std::conditional<HasDestructor<HandleType>::value,
+                                  void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
+                                  void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
+
+      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,
+                           const Dispatcher & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
+        , m_dispatch( &dispatch )
+        , m_allocationCallbacks( allocationCallbacks )
+      {
+      }
+
+    public:
+      template <typename T = HandleType>
+      typename std::enable_if<HasDestructor<T>::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
+      {
+        VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
+        ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
+      }
+
+      template <typename T = HandleType>
+      typename std::enable_if<!HasDestructor<T>::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT
+      {
+        VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
+        ( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch );
+      }
+
+    private:
+      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy             = nullptr;
+      const detail::DispatchLoaderBase *                     m_dispatch            = nullptr;
+      Optional<const AllocationCallbacks>                    m_allocationCallbacks = nullptr;
+    };
+
+    template <typename HandleType>
+    class ObjectFreeShared
    {
-      VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
-      ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
-    }
+    public:
+      using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;

-    template <typename T = HandleType>
-    typename std::enable_if<!HasDestructor<T>::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT
+      template <class Dispatcher>
+      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,
+                        const Dispatcher & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
+        , m_dispatch( &dispatch )
+        , m_allocationCallbacks( allocationCallbacks )
+      {
+      }
+
+    public:
+      void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
+      {
+        VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
+        ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
+      }
+
+    private:
+      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy             = nullptr;
+      const detail::DispatchLoaderBase *                     m_dispatch            = nullptr;
+      Optional<const AllocationCallbacks>                    m_allocationCallbacks = nullptr;
+    };
+
+    template <typename HandleType>
+    class ObjectReleaseShared
    {
-      VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
-      ( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch );
-    }
+    public:
+      using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;

-  private:
-    DestroyFunctionPointerType<DispatchLoaderBase> m_destroy             = nullptr;
-    const DispatchLoaderBase *                     m_dispatch            = nullptr;
-    Optional<const AllocationCallbacks>            m_allocationCallbacks = nullptr;
-  };
+      template <class Dispatcher>
+      using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;

-  template <typename HandleType>
-  class ObjectFreeShared
-  {
-  public:
-    using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
+      template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+      ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
+        , m_dispatch( &dispatch )
+      {
+      }

-    template <class Dispatcher>
-    using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
+    public:
+      void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
+      {
+        VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
+        ( parent.*m_destroy )( handle, *m_dispatch );
+      }

-    template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
-                      const Dispatcher & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-      : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
-      , m_dispatch( &dispatch )
-      , m_allocationCallbacks( allocationCallbacks )
+    private:
+      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy  = nullptr;
+      const detail::DispatchLoaderBase *                     m_dispatch = nullptr;
+    };
+
+    template <typename HandleType, typename PoolType>
+    class PoolFreeShared
    {
-    }
+    public:
+      using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;

-  public:
-    void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
-      ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
-    }
+      using PoolTypeExport = PoolType;

-  private:
-    DestroyFunctionPointerType<DispatchLoaderBase> m_destroy             = nullptr;
-    const DispatchLoaderBase *                     m_dispatch            = nullptr;
-    Optional<const AllocationCallbacks>            m_allocationCallbacks = nullptr;
-  };
+      template <class Dispatcher>
+      using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );

-  template <typename HandleType>
-  class ObjectReleaseShared
-  {
-  public:
-    using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
+      template <class Dispatcher>
+      using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;

-    template <class Dispatcher>
-    using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
+      PoolFreeShared() = default;

-    template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-      : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
-      , m_dispatch( &dispatch )
-    {
-    }
+      template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+      PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
+        , m_dispatch( &dispatch )
+        , m_pool( std::move( pool ) )
+      {
+      }

-  public:
-    void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
-      ( parent.*m_destroy )( handle, *m_dispatch );
-    }
+    public:
+      void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
+      {
+        VULKAN_HPP_ASSERT( m_destroy && m_dispatch && m_pool );
+        ( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
+      }

-  private:
-    DestroyFunctionPointerType<DispatchLoaderBase> m_destroy  = nullptr;
-    const DispatchLoaderBase *                     m_dispatch = nullptr;
-  };
-
-  template <typename HandleType, typename PoolType>
-  class PoolFreeShared
-  {
-  public:
-    using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
-
-    using PoolTypeExport = PoolType;
-
-    template <class Dispatcher>
-    using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
-
-    template <class Dispatcher>
-    using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
-
-    PoolFreeShared() = default;
-
-    template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-      : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
-      , m_dispatch( &dispatch )
-      , m_pool( std::move( pool ) )
-    {
-    }
-
-  public:
-    void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( m_destroy && m_dispatch && m_pool );
-      ( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
-    }
-
-  private:
-    DestroyFunctionPointerType<DispatchLoaderBase> m_destroy  = nullptr;
-    const DispatchLoaderBase *                     m_dispatch = nullptr;
-    SharedHandle<PoolType>                         m_pool{};
-  };
+    private:
+      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy  = nullptr;
+      const detail::DispatchLoaderBase *                     m_dispatch = nullptr;
+      SharedHandle<PoolType>                                 m_pool{};
+    };

 #  if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
 #    pragma GCC diagnostic pop
+#  elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
+#    pragma clang diagnostic pop
 #  endif

+  }  // namespace detail
+
  //======================
  //=== SHARED HANDLEs ===
  //======================
@@ -471,7 +478,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = NoDestructor;
-    using deleter        = ObjectDestroyShared<Instance>;
+    using deleter        = detail::ObjectDestroyShared<Instance>;
  };

  using SharedInstance = SharedHandle<Instance>;
@@ -481,7 +488,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = NoDestructor;
-    using deleter        = ObjectDestroyShared<Device>;
+    using deleter        = detail::ObjectDestroyShared<Device>;
  };

  using SharedDevice = SharedHandle<Device>;
@@ -491,7 +498,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectFreeShared<DeviceMemory>;
+    using deleter        = detail::ObjectFreeShared<DeviceMemory>;
  };

  using SharedDeviceMemory = SharedHandle<DeviceMemory>;
@@ -501,7 +508,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Fence>;
+    using deleter        = detail::ObjectDestroyShared<Fence>;
  };

  using SharedFence = SharedHandle<Fence>;
@@ -511,7 +518,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Semaphore>;
+    using deleter        = detail::ObjectDestroyShared<Semaphore>;
  };

  using SharedSemaphore = SharedHandle<Semaphore>;
@@ -521,7 +528,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Event>;
+    using deleter        = detail::ObjectDestroyShared<Event>;
  };

  using SharedEvent = SharedHandle<Event>;
@@ -531,7 +538,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<QueryPool>;
+    using deleter        = detail::ObjectDestroyShared<QueryPool>;
  };

  using SharedQueryPool = SharedHandle<QueryPool>;
@@ -541,7 +548,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Buffer>;
+    using deleter        = detail::ObjectDestroyShared<Buffer>;
  };

  using SharedBuffer = SharedHandle<Buffer>;
@@ -551,7 +558,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<BufferView>;
+    using deleter        = detail::ObjectDestroyShared<BufferView>;
  };

  using SharedBufferView = SharedHandle<BufferView>;
@@ -561,7 +568,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Image>;
+    using deleter        = detail::ObjectDestroyShared<Image>;
  };

  using SharedImage = SharedHandle<Image>;
@@ -571,7 +578,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<ImageView>;
+    using deleter        = detail::ObjectDestroyShared<ImageView>;
  };

  using SharedImageView = SharedHandle<ImageView>;
@@ -581,7 +588,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<ShaderModule>;
+    using deleter        = detail::ObjectDestroyShared<ShaderModule>;
  };

  using SharedShaderModule = SharedHandle<ShaderModule>;
@@ -591,7 +598,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PipelineCache>;
+    using deleter        = detail::ObjectDestroyShared<PipelineCache>;
  };

  using SharedPipelineCache = SharedHandle<PipelineCache>;
@@ -601,7 +608,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Pipeline>;
+    using deleter        = detail::ObjectDestroyShared<Pipeline>;
  };

  using SharedPipeline = SharedHandle<Pipeline>;
@@ -611,7 +618,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PipelineLayout>;
+    using deleter        = detail::ObjectDestroyShared<PipelineLayout>;
  };

  using SharedPipelineLayout = SharedHandle<PipelineLayout>;
@@ -621,7 +628,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Sampler>;
+    using deleter        = detail::ObjectDestroyShared<Sampler>;
  };

  using SharedSampler = SharedHandle<Sampler>;
@@ -631,7 +638,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<DescriptorPool>;
+    using deleter        = detail::ObjectDestroyShared<DescriptorPool>;
  };

  using SharedDescriptorPool = SharedHandle<DescriptorPool>;
@@ -641,7 +648,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = PoolFreeShared<DescriptorSet, DescriptorPool>;
+    using deleter        = detail::PoolFreeShared<DescriptorSet, DescriptorPool>;
  };

  using SharedDescriptorSet = SharedHandle<DescriptorSet>;
@@ -651,7 +658,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<DescriptorSetLayout>;
+    using deleter        = detail::ObjectDestroyShared<DescriptorSetLayout>;
  };

  using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
@@ -661,7 +668,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<Framebuffer>;
+    using deleter        = detail::ObjectDestroyShared<Framebuffer>;
  };

  using SharedFramebuffer = SharedHandle<Framebuffer>;
@@ -671,7 +678,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<RenderPass>;
+    using deleter        = detail::ObjectDestroyShared<RenderPass>;
  };

  using SharedRenderPass = SharedHandle<RenderPass>;
@@ -681,7 +688,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CommandPool>;
+    using deleter        = detail::ObjectDestroyShared<CommandPool>;
  };

  using SharedCommandPool = SharedHandle<CommandPool>;
@@ -691,7 +698,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = PoolFreeShared<CommandBuffer, CommandPool>;
+    using deleter        = detail::PoolFreeShared<CommandBuffer, CommandPool>;
  };

  using SharedCommandBuffer = SharedHandle<CommandBuffer>;
@@ -702,7 +709,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<SamplerYcbcrConversion>;
+    using deleter        = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
  };

  using SharedSamplerYcbcrConversion    = SharedHandle<SamplerYcbcrConversion>;
@@ -713,7 +720,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<DescriptorUpdateTemplate>;
+    using deleter        = detail::ObjectDestroyShared<DescriptorUpdateTemplate>;
  };

  using SharedDescriptorUpdateTemplate    = SharedHandle<DescriptorUpdateTemplate>;
@@ -725,7 +732,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PrivateDataSlot>;
+    using deleter        = detail::ObjectDestroyShared<PrivateDataSlot>;
  };

  using SharedPrivateDataSlot    = SharedHandle<PrivateDataSlot>;
@@ -737,7 +744,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Instance;
-    using deleter        = ObjectDestroyShared<SurfaceKHR>;
+    using deleter        = detail::ObjectDestroyShared<SurfaceKHR>;
  };

  using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
@@ -748,7 +755,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<SwapchainKHR>;
+    using deleter        = detail::ObjectDestroyShared<SwapchainKHR>;
  };

  using SharedSwapchainKHR = SharedHandle<SwapchainKHR>;
@@ -759,7 +766,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = PhysicalDevice;
-    using deleter        = ObjectDestroyShared<DisplayKHR>;
+    using deleter        = detail::ObjectDestroyShared<DisplayKHR>;
  };

  using SharedDisplayKHR = SharedHandle<DisplayKHR>;
@@ -770,7 +777,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Instance;
-    using deleter        = ObjectDestroyShared<DebugReportCallbackEXT>;
+    using deleter        = detail::ObjectDestroyShared<DebugReportCallbackEXT>;
  };

  using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>;
@@ -781,7 +788,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<VideoSessionKHR>;
+    using deleter        = detail::ObjectDestroyShared<VideoSessionKHR>;
  };

  using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>;
@@ -791,7 +798,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<VideoSessionParametersKHR>;
+    using deleter        = detail::ObjectDestroyShared<VideoSessionParametersKHR>;
  };

  using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>;
@@ -802,7 +809,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CuModuleNVX>;
+    using deleter        = detail::ObjectDestroyShared<CuModuleNVX>;
  };

  using SharedCuModuleNVX = SharedHandle<CuModuleNVX>;
@@ -812,7 +819,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CuFunctionNVX>;
+    using deleter        = detail::ObjectDestroyShared<CuFunctionNVX>;
  };

  using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>;
@@ -823,7 +830,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Instance;
-    using deleter        = ObjectDestroyShared<DebugUtilsMessengerEXT>;
+    using deleter        = detail::ObjectDestroyShared<DebugUtilsMessengerEXT>;
  };

  using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
@@ -834,7 +841,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<AccelerationStructureKHR>;
+    using deleter        = detail::ObjectDestroyShared<AccelerationStructureKHR>;
  };

  using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>;
@@ -845,7 +852,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<ValidationCacheEXT>;
+    using deleter        = detail::ObjectDestroyShared<ValidationCacheEXT>;
  };

  using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>;
@@ -856,7 +863,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<AccelerationStructureNV>;
+    using deleter        = detail::ObjectDestroyShared<AccelerationStructureNV>;
  };

  using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>;
@@ -867,7 +874,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PerformanceConfigurationINTEL>;
+    using deleter        = detail::ObjectDestroyShared<PerformanceConfigurationINTEL>;
  };

  using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>;
@@ -878,7 +885,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<DeferredOperationKHR>;
+    using deleter        = detail::ObjectDestroyShared<DeferredOperationKHR>;
  };

  using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>;
@@ -889,7 +896,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<IndirectCommandsLayoutNV>;
+    using deleter        = detail::ObjectDestroyShared<IndirectCommandsLayoutNV>;
  };

  using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>;
@@ -901,7 +908,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CudaModuleNV>;
+    using deleter        = detail::ObjectDestroyShared<CudaModuleNV>;
  };

  using SharedCudaModuleNV = SharedHandle<CudaModuleNV>;
@@ -911,7 +918,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<CudaFunctionNV>;
+    using deleter        = detail::ObjectDestroyShared<CudaFunctionNV>;
  };

  using SharedCudaFunctionNV = SharedHandle<CudaFunctionNV>;
@@ -924,7 +931,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<BufferCollectionFUCHSIA>;
+    using deleter        = detail::ObjectDestroyShared<BufferCollectionFUCHSIA>;
  };

  using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>;
@@ -936,7 +943,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<MicromapEXT>;
+    using deleter        = detail::ObjectDestroyShared<MicromapEXT>;
  };

  using SharedMicromapEXT = SharedHandle<MicromapEXT>;
@@ -947,7 +954,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<OpticalFlowSessionNV>;
+    using deleter        = detail::ObjectDestroyShared<OpticalFlowSessionNV>;
  };

  using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>;
@@ -958,7 +965,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<ShaderEXT>;
+    using deleter        = detail::ObjectDestroyShared<ShaderEXT>;
  };

  using SharedShaderEXT = SharedHandle<ShaderEXT>;
@@ -969,7 +976,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<PipelineBinaryKHR>;
+    using deleter        = detail::ObjectDestroyShared<PipelineBinaryKHR>;
  };

  using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>;
@@ -980,7 +987,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<IndirectCommandsLayoutEXT>;
+    using deleter        = detail::ObjectDestroyShared<IndirectCommandsLayoutEXT>;
  };

  using SharedIndirectCommandsLayoutEXT = SharedHandle<IndirectCommandsLayoutEXT>;
@@ -990,7 +997,7 @@ namespace VULKAN_HPP_NAMESPACE
  {
  public:
    using DestructorType = Device;
-    using deleter        = ObjectDestroyShared<IndirectExecutionSetEXT>;
+    using deleter        = detail::ObjectDestroyShared<IndirectExecutionSetEXT>;
  };

  using SharedIndirectExecutionSetEXT = SharedHandle<IndirectExecutionSetEXT>;
@@ -2,7 +2,7 @@
 #define VULKAN_VI_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -1,4 +1,4 @@
-// Copyright 2021-2024 The Khronos Group Inc.
+// Copyright 2021-2025 The Khronos Group Inc.
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 //

@@ -7,8 +7,15 @@
 #ifndef VULKAN_VIDEO_HPP
 #define VULKAN_VIDEO_HPP

+// clang-format off
+#include <vulkan/vulkan.hpp>
+// clang-format on
+
 #include <vk_video/vulkan_video_codec_av1std.h>
 #include <vk_video/vulkan_video_codec_av1std_decode.h>
+#if ( 301 < VK_HEADER_VERSION )
+#  include <vk_video/vulkan_video_codec_av1std_encode.h>
+#endif
 #include <vk_video/vulkan_video_codec_h264std.h>
 #include <vk_video/vulkan_video_codec_h264std_decode.h>
 #include <vk_video/vulkan_video_codec_h264std_encode.h>
@@ -16,7 +23,6 @@
 #include <vk_video/vulkan_video_codec_h265std_decode.h>
 #include <vk_video/vulkan_video_codec_h265std_encode.h>
 #include <vk_video/vulkan_video_codecs_common.h>
-#include <vulkan/vulkan.hpp>

 #if !defined( VULKAN_HPP_VIDEO_NAMESPACE )
 #  define VULKAN_HPP_VIDEO_NAMESPACE video
@@ -358,19 +364,21 @@ namespace VULKAN_HPP_NAMESPACE

    enum class AV1ColorPrimaries
    {
-      eBt709         = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709,
-      eBtUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED,
-      eBt470M        = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M,
-      eBt470BG       = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G,
-      eBt601         = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601,
-      eSmpte240      = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240,
-      eGenericFilm   = STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM,
-      eBt2020        = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020,
-      eXyz           = STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ,
-      eSmpte431      = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431,
-      eSmpte432      = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432,
-      eEbu3213       = STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213,
-      eInvalid       = STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID
+      eBt709       = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709,
+      eUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED,
+      eBtUnspecified VULKAN_HPP_DEPRECATED_17( "eBtUnspecified is deprecated, eUnspecified should be used instead." ) =
+        STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED,
+      eBt470M      = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M,
+      eBt470BG     = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G,
+      eBt601       = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601,
+      eSmpte240    = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240,
+      eGenericFilm = STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM,
+      eBt2020      = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020,
+      eXyz         = STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ,
+      eSmpte431    = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431,
+      eSmpte432    = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432,
+      eEbu3213     = STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213,
+      eInvalid     = STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID
    };

    enum class AV1TransferCharacteristics
@@ -3711,6 +3719,339 @@ namespace VULKAN_HPP_NAMESPACE
      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES>   SavedOrderHints  = {};
    };

+    //=== vulkan_video_codec_av1std_encode ===
+
+    struct EncodeAV1DecoderModelInfo
+    {
+      using NativeType = StdVideoEncodeAV1DecoderModelInfo;
+
+      operator StdVideoEncodeAV1DecoderModelInfo const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1DecoderModelInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1DecoderModelInfo &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1DecoderModelInfo *>( this );
+      }
+
+      bool operator==( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( buffer_delay_length_minus_1 == rhs.buffer_delay_length_minus_1 ) &&
+               ( buffer_removal_time_length_minus_1 == rhs.buffer_removal_time_length_minus_1 ) &&
+               ( frame_presentation_time_length_minus_1 == rhs.frame_presentation_time_length_minus_1 ) && ( reserved1 == rhs.reserved1 ) &&
+               ( num_units_in_decoding_tick == rhs.num_units_in_decoding_tick );
+      }
+
+      bool operator!=( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint8_t  buffer_delay_length_minus_1            = {};
+      uint8_t  buffer_removal_time_length_minus_1     = {};
+      uint8_t  frame_presentation_time_length_minus_1 = {};
+      uint8_t  reserved1                              = {};
+      uint32_t num_units_in_decoding_tick             = {};
+    };
+
+    struct EncodeAV1ExtensionHeader
+    {
+      using NativeType = StdVideoEncodeAV1ExtensionHeader;
+
+      operator StdVideoEncodeAV1ExtensionHeader const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1ExtensionHeader *>( this );
+      }
+
+      operator StdVideoEncodeAV1ExtensionHeader &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1ExtensionHeader *>( this );
+      }
+
+      bool operator==( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( temporal_id == rhs.temporal_id ) && ( spatial_id == rhs.spatial_id );
+      }
+
+      bool operator!=( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint8_t temporal_id = {};
+      uint8_t spatial_id  = {};
+    };
+
+    struct EncodeAV1OperatingPointInfoFlags
+    {
+      using NativeType = StdVideoEncodeAV1OperatingPointInfoFlags;
+
+      operator StdVideoEncodeAV1OperatingPointInfoFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeAV1OperatingPointInfoFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfoFlags *>( this );
+      }
+
+      bool operator==( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( decoder_model_present_for_this_op == rhs.decoder_model_present_for_this_op ) && ( low_delay_mode_flag == rhs.low_delay_mode_flag ) &&
+               ( initial_display_delay_present_for_this_op == rhs.initial_display_delay_present_for_this_op ) && ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint32_t decoder_model_present_for_this_op         : 1;
+      uint32_t low_delay_mode_flag                       : 1;
+      uint32_t initial_display_delay_present_for_this_op : 1;
+      uint32_t reserved                                  : 29;
+    };
+
+    struct EncodeAV1OperatingPointInfo
+    {
+      using NativeType = StdVideoEncodeAV1OperatingPointInfo;
+
+      operator StdVideoEncodeAV1OperatingPointInfo const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1OperatingPointInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1OperatingPointInfo &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1OperatingPointInfo *>( this );
+      }
+
+      bool operator==( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( operating_point_idc == rhs.operating_point_idc ) && ( seq_level_idx == rhs.seq_level_idx ) &&
+               ( seq_tier == rhs.seq_tier ) && ( decoder_buffer_delay == rhs.decoder_buffer_delay ) && ( encoder_buffer_delay == rhs.encoder_buffer_delay ) &&
+               ( initial_display_delay_minus_1 == rhs.initial_display_delay_minus_1 );
+      }
+
+      bool operator!=( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags flags                         = {};
+      uint16_t                                                                           operating_point_idc           = {};
+      uint8_t                                                                            seq_level_idx                 = {};
+      uint8_t                                                                            seq_tier                      = {};
+      uint32_t                                                                           decoder_buffer_delay          = {};
+      uint32_t                                                                           encoder_buffer_delay          = {};
+      uint8_t                                                                            initial_display_delay_minus_1 = {};
+    };
+
+    struct EncodeAV1PictureInfoFlags
+    {
+      using NativeType = StdVideoEncodeAV1PictureInfoFlags;
+
+      operator StdVideoEncodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1PictureInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1PictureInfoFlags *>( this );
+      }
+
+      bool operator==( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) &&
+               ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) &&
+               ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) &&
+               ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) &&
+               ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) &&
+               ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) &&
+               ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) &&
+               ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) &&
+               ( reduced_tx_set == rhs.reduced_tx_set ) && ( skip_mode_present == rhs.skip_mode_present ) && ( delta_q_present == rhs.delta_q_present ) &&
+               ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) &&
+               ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) &&
+               ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) &&
+               ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( show_frame == rhs.show_frame ) &&
+               ( showable_frame == rhs.showable_frame ) && ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint32_t error_resilient_mode             : 1;
+      uint32_t disable_cdf_update               : 1;
+      uint32_t use_superres                     : 1;
+      uint32_t render_and_frame_size_different  : 1;
+      uint32_t allow_screen_content_tools       : 1;
+      uint32_t is_filter_switchable             : 1;
+      uint32_t force_integer_mv                 : 1;
+      uint32_t frame_size_override_flag         : 1;
+      uint32_t buffer_removal_time_present_flag : 1;
+      uint32_t allow_intrabc                    : 1;
+      uint32_t frame_refs_short_signaling       : 1;
+      uint32_t allow_high_precision_mv          : 1;
+      uint32_t is_motion_mode_switchable        : 1;
+      uint32_t use_ref_frame_mvs                : 1;
+      uint32_t disable_frame_end_update_cdf     : 1;
+      uint32_t allow_warped_motion              : 1;
+      uint32_t reduced_tx_set                   : 1;
+      uint32_t skip_mode_present                : 1;
+      uint32_t delta_q_present                  : 1;
+      uint32_t delta_lf_present                 : 1;
+      uint32_t delta_lf_multi                   : 1;
+      uint32_t segmentation_enabled             : 1;
+      uint32_t segmentation_update_map          : 1;
+      uint32_t segmentation_temporal_update     : 1;
+      uint32_t segmentation_update_data         : 1;
+      uint32_t UsesLr                           : 1;
+      uint32_t usesChromaLr                     : 1;
+      uint32_t show_frame                       : 1;
+      uint32_t showable_frame                   : 1;
+      uint32_t reserved                         : 3;
+    };
+
+    struct EncodeAV1PictureInfo
+    {
+      using NativeType = StdVideoEncodeAV1PictureInfo;
+
+      operator StdVideoEncodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1PictureInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1PictureInfo *>( this );
+      }
+
+      bool operator==( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( frame_presentation_time == rhs.frame_presentation_time ) &&
+               ( current_frame_id == rhs.current_frame_id ) && ( order_hint == rhs.order_hint ) && ( primary_ref_frame == rhs.primary_ref_frame ) &&
+               ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( coded_denom == rhs.coded_denom ) &&
+               ( render_width_minus_1 == rhs.render_width_minus_1 ) && ( render_height_minus_1 == rhs.render_height_minus_1 ) &&
+               ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) &&
+               ( delta_lf_res == rhs.delta_lf_res ) && ( ref_order_hint == rhs.ref_order_hint ) && ( ref_frame_idx == rhs.ref_frame_idx ) &&
+               ( reserved1 == rhs.reserved1 ) && ( delta_frame_id_minus_1 == rhs.delta_frame_id_minus_1 ) && ( pTileInfo == rhs.pTileInfo ) &&
+               ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && ( pLoopFilter == rhs.pLoopFilter ) &&
+               ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && ( pGlobalMotion == rhs.pGlobalMotion ) &&
+               ( pExtensionHeader == rhs.pExtensionHeader ) && ( pBufferRemovalTimes == rhs.pBufferRemovalTimes );
+      }
+
+      bool operator!=( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags flags = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type         = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
+      uint32_t                                                       frame_presentation_time = {};
+      uint32_t                                                       current_frame_id        = {};
+      uint8_t                                                        order_hint              = {};
+      uint8_t                                                        primary_ref_frame       = {};
+      uint8_t                                                        refresh_frame_flags     = {};
+      uint8_t                                                        coded_denom             = {};
+      uint16_t                                                       render_width_minus_1    = {};
+      uint16_t                                                       render_height_minus_1   = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter =
+        VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap;
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode       = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4;
+      uint8_t                                                     delta_q_res  = {};
+      uint8_t                                                     delta_lf_res = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES>        ref_order_hint         = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_REFS_PER_FRAME>         ref_frame_idx          = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3>                                   reserved1              = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_REFS_PER_FRAME>       delta_frame_id_minus_1 = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo *              pTileInfo              = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization *          pQuantization          = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation *          pSegmentation          = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter *            pLoopFilter            = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF *                  pCDEF                  = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration *       pLoopRestoration       = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion *          pGlobalMotion          = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader       = {};
+      const uint32_t *                                                                   pBufferRemovalTimes    = {};
+    };
+
+    struct EncodeAV1ReferenceInfoFlags
+    {
+      using NativeType = StdVideoEncodeAV1ReferenceInfoFlags;
+
+      operator StdVideoEncodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1ReferenceInfoFlags *>( this );
+      }
+
+      operator StdVideoEncodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfoFlags *>( this );
+      }
+
+      bool operator==( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) &&
+               ( reserved == rhs.reserved );
+      }
+
+      bool operator!=( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      uint32_t disable_frame_end_update_cdf : 1;
+      uint32_t segmentation_enabled         : 1;
+      uint32_t reserved                     : 30;
+    };
+
+    struct EncodeAV1ReferenceInfo
+    {
+      using NativeType = StdVideoEncodeAV1ReferenceInfo;
+
+      operator StdVideoEncodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<const StdVideoEncodeAV1ReferenceInfo *>( this );
+      }
+
+      operator StdVideoEncodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT
+      {
+        return *reinterpret_cast<StdVideoEncodeAV1ReferenceInfo *>( this );
+      }
+
+      bool operator==( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ( flags == rhs.flags ) && ( RefFrameId == rhs.RefFrameId ) && ( frame_type == rhs.frame_type ) && ( OrderHint == rhs.OrderHint ) &&
+               ( reserved1 == rhs.reserved1 ) && ( pExtensionHeader == rhs.pExtensionHeader );
+      }
+
+      bool operator!=( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
+      {
+        return !operator==( rhs );
+      }
+
+    public:
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags flags      = {};
+      uint32_t                                                                      RefFrameId = {};
+      VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
+      uint8_t                                                        OrderHint  = {};
+      VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3>               reserved1  = {};
+      const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {};
+    };
+
  }  // namespace VULKAN_HPP_VIDEO_NAMESPACE
 }  // namespace VULKAN_HPP_NAMESPACE
 #endif
@@ -2,7 +2,7 @@
 #define VULKAN_WAYLAND_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_WIN32_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_XCB_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_XLIB_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -2,7 +2,7 @@
 #define VULKAN_XLIB_XRANDR_H_ 1

 /*
-** Copyright 2015-2024 The Khronos Group Inc.
+** Copyright 2015-2025 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */