Update for Vulkan-Docs 1.4.312

adjusted fnc name
simplified cpp module to not require function loading
2025-04-10 06:48:03 +00:00 · 2025-04-04 04:45:22 -07:00 · 2025-03-31 09:52:53 -06:00 · 2025-03-31 09:52:53 -06:00 · 2025-03-31 09:52:53 -06:00 · 2025-03-31 09:52:53 -06:00
30 changed files with 9645 additions and 2552 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -74,6 +74,58 @@ jobs:
        - run: ctest --output-on-failure
          working-directory: build

+  cmake-unix-modules:
+    runs-on: ${{ matrix.os }}
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+    strategy:
+      matrix:
+        os: [ ubuntu-latest ]
+        cmake-version: [ 'latest' ]
+        compiler: [ clang++-18 ]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: ${{ matrix.cmake-version }}
+      - uses: ilammy/msvc-dev-cmd@v1
+      - run: |
+          cmake -S . -B build \
+          -D VULKAN_HEADERS_ENABLE_TESTS=ON \
+          -D VULKAN_HEADERS_ENABLE_INSTALL=ON \
+          -D VULKAN_HEADERS_ENABLE_MODULE=ON \
+          -D VULKAN_HEADERS_ENABLE_MODULE_STD=OFF \
+          -D CMAKE_CXX_COMPILER=${{ matrix.compiler }} \
+          -G Ninja
+      - run: cmake --build ./build
+      - run: cmake --install build/ --prefix build/install
+      - run: CXX=${{ matrix.compiler }} ctest --output-on-failure
+        working-directory: build
+
+  cmake-windows-modules:
+    runs-on: ${{ matrix.os }}
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+    strategy:
+      matrix:
+        os: [ windows-latest ]
+        cmake-version: [ 'latest' ]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: ${{ matrix.cmake-version }}
+      - uses: ilammy/msvc-dev-cmd@v1
+      - run: |
+          cmake -S . -B build `
+          -D VULKAN_HEADERS_ENABLE_TESTS=ON `
+          -D VULKAN_HEADERS_ENABLE_INSTALL=ON `
+          -D VULKAN_HEADERS_ENABLE_MODULE=ON `
+          -D VULKAN_HEADERS_ENABLE_MODULE_STD=OFF `
+          -G Ninja
+      - run: cmake --build ./build
+      - run: cmake --install build/ --prefix build/install
+      - run: ctest --output-on-failure
+        working-directory: build
+
  reuse:
    runs-on: ubuntu-latest
    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -38,42 +38,67 @@ vlk_get_header_version()

 project(VULKAN_HEADERS LANGUAGES C CXX VERSION ${VK_VERSION_STRING})

+# options for Vulkan-Headers and the Vulkan-Hpp C++20 module
+option(VULKAN_HEADERS_ENABLE_TESTS "Test Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
+option(VULKAN_HEADERS_ENABLE_INSTALL "Install Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
+option(VULKAN_HEADERS_ENABLE_MODULE "Enables building of the Vulkan C++20 module; requires minimum CMake version 3.28" OFF)
+option(VULKAN_HEADERS_ENABLE_MODULE_STD "Enables building of the Vulkan C++20 module with import std; requires minimum CMake version 3.30" OFF)
+
+# set up Vulkan-Headers
 add_library(Vulkan-Headers INTERFACE)
 add_library(Vulkan::Headers ALIAS Vulkan-Headers)
 target_include_directories(Vulkan-Headers INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)

-if ((CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND (MSVC_VERSION GREATER_EQUAL "1941")) OR
-    # clang-cl doesn't currently support modules
-    (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
-        AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "16.0"
-        AND (NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "MSVC")
-        AND (NOT CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS STREQUAL CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS-NOTFOUND)) OR
-    (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0"))
-    set(COMPILER_SUPPORTS_CXX_MODULES TRUE)
-endif()
-
-option(VULKAN_HEADERS_ENABLE_MODULE "Enables building of the Vulkan C++ module" OFF)
-
-if (VULKAN_HEADERS_ENABLE_MODULE AND (NOT COMPILER_SUPPORTS_CXX_MODULES OR CMAKE_VERSION VERSION_LESS "3.28"))
-    message(WARNING "Vulkan C++ module support is requested but was disabled due to lacking support on this platform")
-endif()
-
-if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.28" AND VULKAN_HEADERS_ENABLE_MODULE AND COMPILER_SUPPORTS_CXX_MODULES)
-    add_library(Vulkan-Module)
-    add_library(Vulkan::VulkanHppModule ALIAS Vulkan-Module)
-    target_sources(Vulkan-Module
-        PUBLIC
-            FILE_SET module
-                TYPE CXX_MODULES
-                BASE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/include"
-                FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan/vulkan.cppm"
+if (VULKAN_HEADERS_ENABLE_MODULE)
+    # check for compiler support
+    if ((CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND (MSVC_VERSION GREATER_EQUAL "1941")) OR
+        # clang-cl doesn't currently support modules
+        (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
+            AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "16.0"
+            AND (NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "MSVC")
+            AND (NOT CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS STREQUAL CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS-NOTFOUND)) OR
+        (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0")
    )
-    target_compile_features(Vulkan-Module PUBLIC cxx_std_20)
-    target_link_libraries(Vulkan-Module PUBLIC Vulkan-Headers)
-endif ()
+        # check for CMake support
+        if(VULKAN_HEADERS_ENABLE_MODULE_STD AND CMAKE_VERSION VERSION_LESS "3.30")
+            message(FATAL_ERROR "Vulkan-Hpp: C++20 module with import std requires CMake 3.30 or later")
+        elseif (CMAKE_VERSION VERSION_LESS "3.28")
+            message(FATAL_ERROR "Vulkan-Hpp: C++20 module requires CMake 3.28 or later")
+        endif()
+        
+        # set up Vulkan-HppModule
+        add_library(Vulkan-HppModule)
+        add_library(Vulkan::HppModule ALIAS Vulkan-HppModule)
+        target_sources(Vulkan-HppModule
+            PUBLIC
+            FILE_SET module
+            TYPE CXX_MODULES
+            FILES "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan/vulkan.cppm")
+        if (VULKAN_HEADERS_ENABLE_MODULE_STD)
+            target_compile_features(Vulkan-HppModule
+                PRIVATE   cxx_std_23
+                INTERFACE cxx_std_20) # only C++20 is required to consume this module
+            set_target_properties(Vulkan-HppModule PROPERTIES CXX_MODULE_STD ON)
+        else()
+            target_compile_features(Vulkan-HppModule PUBLIC cxx_std_20)
+        endif()
+        target_link_libraries(Vulkan-HppModule PUBLIC Vulkan::Headers)

-option(VULKAN_HEADERS_ENABLE_TESTS "Test Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
-option(VULKAN_HEADERS_ENABLE_INSTALL "Install Vulkan-Headers" ${PROJECT_IS_TOP_LEVEL})
+        # Clang 16's module support can be broken with extensions enabled
+        if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "16.0")
+            set_target_properties(Vulkan-HppModule PROPERTIES CXX_EXTENSIONS OFF)
+        endif()
+
+        # set up fallback targets to notify about name deprecation
+        add_library(Vulkan-Module INTERFACE)
+        add_library(Vulkan::Module ALIAS Vulkan-Module)
+        target_link_libraries(Vulkan-Module INTERFACE Vulkan::HppModule)
+        set_target_properties(Vulkan-Module PROPERTIES 
+            DEPRECATION "The Vulkan-Module and Vulkan::Module targets have been deprecated by the Vulkan-HppModule and Vulkan::HppModule targets respectively and will be removed at a future date.")
+    else()
+        message(FATAL_ERROR "Vulkan-Hpp: C++20 module support is requested but was disabled due to lacking compiler support on this platform")
+    endif()
+endif()

 if (VULKAN_HEADERS_ENABLE_TESTS)
    enable_testing() # This is only effective in the top level CMakeLists.txt file.
--- a/include/vulkan/vulkan.cppm
+++ b/include/vulkan/vulkan.cppm
@ -753,6 +753,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV;
  using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV;

+  //=== VK_QCOM_tile_shading ===
+  using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagBitsQCOM;
+  using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM;
+
 #if defined( VK_USE_PLATFORM_METAL_EXT )
  //=== VK_EXT_metal_objects ===
  using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagBitsEXT;
@ -1555,6 +1559,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportExtensionName;
  using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportSpecVersion;

+  //=== VK_KHR_shader_bfloat16 ===
+  using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16ExtensionName;
+  using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16SpecVersion;
+
  //=== VK_EXT_sample_locations ===
  using VULKAN_HPP_NAMESPACE::EXTSampleLocationsExtensionName;
  using VULKAN_HPP_NAMESPACE::EXTSampleLocationsSpecVersion;
@ -2088,6 +2096,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::NVCudaKernelLaunchSpecVersion;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+  using VULKAN_HPP_NAMESPACE::QCOMTileShadingExtensionName;
+  using VULKAN_HPP_NAMESPACE::QCOMTileShadingSpecVersion;
+
  //=== VK_NV_low_latency ===
  using VULKAN_HPP_NAMESPACE::NVLowLatencyExtensionName;
  using VULKAN_HPP_NAMESPACE::NVLowLatencySpecVersion;
@ -2649,6 +2661,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName;
  using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueExtensionName;
+  using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueSpecVersion;
+
  //=== VK_KHR_shader_relaxed_extended_instruction ===
  using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName;
  using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion;
@ -2734,6 +2750,10 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_EXT_fragment_density_map_offset ===
+  using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetExtensionName;
+  using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetSpecVersion;
+
  //========================
  //=== CONSTEXPR VALUEs ===
  //========================
@ -3723,6 +3743,9 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD;
  using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV;

+  //=== VK_KHR_shader_bfloat16 ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR;
+
  //=== VK_EXT_sample_locations ===
  using VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT;
  using VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT;
@ -4121,6 +4144,14 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+  using VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM;
+  using VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM;
+  using VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM;
+  using VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM;
+
  //=== VK_NV_low_latency ===
  using VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV;

@ -4402,11 +4433,6 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM;
  using VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM;

-  //=== VK_QCOM_fragment_density_map_offset ===
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
-  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
-  using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
-
  //=== VK_NV_copy_memory_indirect ===
  using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV;
  using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV;
@ -4691,6 +4717,12 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_NV_raw_access_chains ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV;
+  using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV;
+  using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV;
+
  //=== VK_KHR_shader_relaxed_extended_instruction ===
  using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;

@ -4820,6 +4852,15 @@ export namespace VULKAN_HPP_NAMESPACE
  using VULKAN_HPP_NAMESPACE::SetPresentConfigNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_EXT_fragment_density_map_offset ===
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+  using VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT;
+  using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT;
+  using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM;
+
  //===============
  //=== HANDLEs ===
  //===============
@ -4925,6 +4966,9 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_KHR_pipeline_binary ===
  using VULKAN_HPP_NAMESPACE::PipelineBinaryKHR;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV;
+
  //=== VK_EXT_device_generated_commands ===
  using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT;
  using VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT;
@ -5031,6 +5075,9 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_KHR_pipeline_binary ===
  using VULKAN_HPP_NAMESPACE::UniquePipelineBinaryKHR;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::UniqueExternalComputeQueueNV;
+
  //=== VK_EXT_device_generated_commands ===
  using VULKAN_HPP_NAMESPACE::UniqueHandleTraits;
  using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutEXT;
@ -5142,6 +5189,9 @@ export namespace VULKAN_HPP_NAMESPACE
  //=== VK_KHR_pipeline_binary ===
  using VULKAN_HPP_NAMESPACE::SharedPipelineBinaryKHR;

+  //=== VK_NV_external_compute_queue ===
+  using VULKAN_HPP_NAMESPACE::SharedExternalComputeQueueNV;
+
  //=== VK_EXT_device_generated_commands ===
  using VULKAN_HPP_NAMESPACE::SharedHandleTraits;
  using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutEXT;
@ -5337,6 +5387,9 @@ export namespace VULKAN_HPP_NAMESPACE
    using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR;
    using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHRs;

+    //=== VK_NV_external_compute_queue ===
+    using VULKAN_HPP_RAII_NAMESPACE::ExternalComputeQueueNV;
+
    //=== VK_EXT_device_generated_commands ===
    using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutEXT;
    using VULKAN_HPP_RAII_NAMESPACE::IndirectExecutionSetEXT;
@ -5509,6 +5562,10 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PipelineBinaryKHR>;

+  //=== VK_NV_external_compute_queue ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>;
+
  //=== VK_EXT_device_generated_commands ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT>;
@ -6771,6 +6828,10 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>;

+  //=== VK_KHR_shader_bfloat16 ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>;
+
  //=== VK_EXT_sample_locations ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>;
@ -7395,6 +7456,20 @@ export namespace std
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV>;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>;
+
  //=== VK_NV_low_latency ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV>;
@ -7831,14 +7906,6 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>;

-  //=== VK_QCOM_fragment_density_map_offset ===
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>;
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>;
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>;
-
  //=== VK_NV_copy_memory_indirect ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV>;
@ -8293,6 +8360,16 @@ export namespace std
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>;

+  //=== VK_NV_external_compute_queue ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>;
+
  //=== VK_KHR_shader_relaxed_extended_instruction ===
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>;
@ -8505,6 +8582,16 @@ export namespace std
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV>;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_EXT_fragment_density_map_offset ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>;
+
  //=================================================================
  //=== Required exports for VULKAN_HPP_NAMESPACE::StructureChain ===
  //=================================================================
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@ -63,7 +63,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <span>
 #endif

-static_assert( VK_HEADER_VERSION == 310, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 312, "Wrong VK_HEADER_VERSION!" );

 // <tuple> includes <sys/sysmacros.h> through some other header
 // this results in major(x) being resolved to gnu_dev_major(x)
@ -4951,6 +4951,23 @@ namespace VULKAN_HPP_NAMESPACE
      }
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/

+      //=== VK_QCOM_tile_shading ===
+
+      void vkCmdDispatchTileQCOM( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdDispatchTileQCOM( commandBuffer );
+      }
+
+      void vkCmdBeginPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM * pPerTileBeginInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdBeginPerTileExecutionQCOM( commandBuffer, pPerTileBeginInfo );
+      }
+
+      void vkCmdEndPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM * pPerTileEndInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndPerTileExecutionQCOM( commandBuffer, pPerTileEndInfo );
+      }
+
 #  if defined( VK_USE_PLATFORM_METAL_EXT )
      //=== VK_EXT_metal_objects ===

@ -6095,6 +6112,30 @@ namespace VULKAN_HPP_NAMESPACE
        return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo );
      }

+      //=== VK_NV_external_compute_queue ===
+
+      VkResult vkCreateExternalComputeQueueNV( VkDevice                                   device,
+                                               const VkExternalComputeQueueCreateInfoNV * pCreateInfo,
+                                               const VkAllocationCallbacks *              pAllocator,
+                                               VkExternalComputeQueueNV *                 pExternalQueue ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCreateExternalComputeQueueNV( device, pCreateInfo, pAllocator, pExternalQueue );
+      }
+
+      void vkDestroyExternalComputeQueueNV( VkDevice                      device,
+                                            VkExternalComputeQueueNV      externalQueue,
+                                            const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkDestroyExternalComputeQueueNV( device, externalQueue, pAllocator );
+      }
+
+      void vkGetExternalComputeQueueDataNV( VkExternalComputeQueueNV             externalQueue,
+                                            VkExternalComputeQueueDataParamsNV * params,
+                                            void *                               pData ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkGetExternalComputeQueueDataNV( externalQueue, params, pData );
+      }
+
      //=== VK_NV_cluster_acceleration_structure ===

      void vkGetClusterAccelerationStructureBuildSizesNV( VkDevice                                          device,
@ -6219,6 +6260,13 @@ namespace VULKAN_HPP_NAMESPACE
        return ::vkGetMemoryMetalHandlePropertiesEXT( device, handleType, pHandle, pMemoryMetalHandleProperties );
      }
 #  endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+      //=== VK_EXT_fragment_density_map_offset ===
+
+      void vkCmdEndRendering2EXT( VkCommandBuffer commandBuffer, const VkRenderingEndInfoEXT * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT
+      {
+        return ::vkCmdEndRendering2EXT( commandBuffer, pRenderingEndInfo );
+      }
    };

    inline DispatchLoaderStatic & getDispatchLoaderStatic()
@ -7799,6 +7847,10 @@ namespace VULKAN_HPP_NAMESPACE
  VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportExtensionName = VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME;
  VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportSpecVersion   = VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION;

+  //=== VK_KHR_shader_bfloat16 ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16ExtensionName = VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16SpecVersion   = VK_KHR_SHADER_BFLOAT16_SPEC_VERSION;
+
  //=== VK_EXT_sample_locations ===
  VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsExtensionName = VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME;
  VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsSpecVersion   = VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION;
@ -8333,6 +8385,10 @@ namespace VULKAN_HPP_NAMESPACE
  VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchSpecVersion   = VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingExtensionName = VK_QCOM_TILE_SHADING_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingSpecVersion   = VK_QCOM_TILE_SHADING_SPEC_VERSION;
+
  //=== VK_NV_low_latency ===
  VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencyExtensionName = VK_NV_LOW_LATENCY_EXTENSION_NAME;
  VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencySpecVersion   = VK_NV_LOW_LATENCY_SPEC_VERSION;
@ -8889,6 +8945,10 @@ namespace VULKAN_HPP_NAMESPACE
  VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsExtensionName = VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME;
  VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsSpecVersion   = VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION;

+  //=== VK_NV_external_compute_queue ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueExtensionName = VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueSpecVersion   = VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION;
+
  //=== VK_KHR_shader_relaxed_extended_instruction ===
  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME;
  VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion   = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION;
@ -8973,6 +9033,10 @@ namespace VULKAN_HPP_NAMESPACE
  VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringSpecVersion   = VK_NV_PRESENT_METERING_SPEC_VERSION;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_EXT_fragment_density_map_offset ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetSpecVersion   = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION;
+
 }  // namespace VULKAN_HPP_NAMESPACE

 // clang-format off
@ -12193,6 +12257,25 @@ namespace VULKAN_HPP_NAMESPACE
    };
  };

+  //=== VK_KHR_shader_bfloat16 ===
+  template <>
+  struct StructExtends<PhysicalDeviceShaderBfloat16FeaturesKHR, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceShaderBfloat16FeaturesKHR, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
  //=== VK_EXT_sample_locations ===
  template <>
  struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier>
@ -14073,6 +14156,70 @@ namespace VULKAN_HPP_NAMESPACE
  };
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+  template <>
+  struct StructExtends<PhysicalDeviceTileShadingFeaturesQCOM, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceTileShadingFeaturesQCOM, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceTileShadingPropertiesQCOM, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderPassTileShadingCreateInfoQCOM, RenderPassCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderPassTileShadingCreateInfoQCOM, RenderPassCreateInfo2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderPassTileShadingCreateInfoQCOM, RenderingInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderPassTileShadingCreateInfoQCOM, CommandBufferInheritanceInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
  //=== VK_NV_low_latency ===
  template <>
  struct StructExtends<QueryLowLatencySupportNV, SemaphoreCreateInfo>
@ -15672,43 +15819,6 @@ namespace VULKAN_HPP_NAMESPACE
    };
  };

-  //=== VK_QCOM_fragment_density_map_offset ===
-  template <>
-  struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, PhysicalDeviceFeatures2>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
-  template <>
-  struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, DeviceCreateInfo>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
-  template <>
-  struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, PhysicalDeviceProperties2>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
-  template <>
-  struct StructExtends<SubpassFragmentDensityMapOffsetEndInfoQCOM, SubpassEndInfo>
-  {
-    enum
-    {
-      value = true
-    };
-  };
-
  //=== VK_NV_copy_memory_indirect ===
  template <>
  struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesNV, PhysicalDeviceFeatures2>
@ -17404,6 +17514,25 @@ namespace VULKAN_HPP_NAMESPACE
    };
  };

+  //=== VK_NV_external_compute_queue ===
+  template <>
+  struct StructExtends<ExternalComputeQueueDeviceCreateInfoNV, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceExternalComputeQueuePropertiesNV, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
  //=== VK_KHR_shader_relaxed_extended_instruction ===
  template <>
  struct StructExtends<PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, PhysicalDeviceFeatures2>
@ -18004,6 +18133,52 @@ namespace VULKAN_HPP_NAMESPACE
  };
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_EXT_fragment_density_map_offset ===
+  template <>
+  struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, PhysicalDeviceProperties2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderPassFragmentDensityMapOffsetEndInfoEXT, SubpassEndInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<RenderPassFragmentDensityMapOffsetEndInfoEXT, RenderingEndInfoEXT>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
 #endif  // VULKAN_HPP_DISABLE_ENHANCED_MODE

  namespace detail
@ -19008,6 +19183,11 @@ namespace VULKAN_HPP_NAMESPACE
      PFN_dummy vkCmdCudaLaunchKernelNV_placeholder                           = 0;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+      //=== VK_QCOM_tile_shading ===
+      PFN_vkCmdDispatchTileQCOM          vkCmdDispatchTileQCOM          = 0;
+      PFN_vkCmdBeginPerTileExecutionQCOM vkCmdBeginPerTileExecutionQCOM = 0;
+      PFN_vkCmdEndPerTileExecutionQCOM   vkCmdEndPerTileExecutionQCOM   = 0;
+
 #if defined( VK_USE_PLATFORM_METAL_EXT )
      //=== VK_EXT_metal_objects ===
      PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0;
@ -19304,6 +19484,11 @@ namespace VULKAN_HPP_NAMESPACE
      PFN_vkCmdSetDescriptorBufferOffsets2EXT           vkCmdSetDescriptorBufferOffsets2EXT           = 0;
      PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0;

+      //=== VK_NV_external_compute_queue ===
+      PFN_vkCreateExternalComputeQueueNV  vkCreateExternalComputeQueueNV  = 0;
+      PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0;
+      PFN_vkGetExternalComputeQueueDataNV vkGetExternalComputeQueueDataNV = 0;
+
      //=== VK_NV_cluster_acceleration_structure ===
      PFN_vkGetClusterAccelerationStructureBuildSizesNV    vkGetClusterAccelerationStructureBuildSizesNV    = 0;
      PFN_vkCmdBuildClusterAccelerationStructureIndirectNV vkCmdBuildClusterAccelerationStructureIndirectNV = 0;
@ -19335,6 +19520,9 @@ namespace VULKAN_HPP_NAMESPACE
      PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder               = 0;
 #endif /*VK_USE_PLATFORM_METAL_EXT*/

+      //=== VK_EXT_fragment_density_map_offset ===
+      PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0;
+
    public:
      DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT                                    = default;
      DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
@ -20473,6 +20661,11 @@ namespace VULKAN_HPP_NAMESPACE
        vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetInstanceProcAddr( instance, "vkCmdCudaLaunchKernelNV" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+        //=== VK_QCOM_tile_shading ===
+        vkCmdDispatchTileQCOM          = PFN_vkCmdDispatchTileQCOM( vkGetInstanceProcAddr( instance, "vkCmdDispatchTileQCOM" ) );
+        vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdBeginPerTileExecutionQCOM" ) );
+        vkCmdEndPerTileExecutionQCOM   = PFN_vkCmdEndPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdEndPerTileExecutionQCOM" ) );
+
 #if defined( VK_USE_PLATFORM_METAL_EXT )
        //=== VK_EXT_metal_objects ===
        vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetInstanceProcAddr( instance, "vkExportMetalObjectsEXT" ) );
@ -20840,6 +21033,11 @@ namespace VULKAN_HPP_NAMESPACE
        vkCmdBindDescriptorBufferEmbeddedSamplers2EXT =
          PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );

+        //=== VK_NV_external_compute_queue ===
+        vkCreateExternalComputeQueueNV  = PFN_vkCreateExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkCreateExternalComputeQueueNV" ) );
+        vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkDestroyExternalComputeQueueNV" ) );
+        vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetInstanceProcAddr( instance, "vkGetExternalComputeQueueDataNV" ) );
+
        //=== VK_NV_cluster_acceleration_structure ===
        vkGetClusterAccelerationStructureBuildSizesNV =
          PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetInstanceProcAddr( instance, "vkGetClusterAccelerationStructureBuildSizesNV" ) );
@ -20877,6 +21075,9 @@ namespace VULKAN_HPP_NAMESPACE
        vkGetMemoryMetalHandlePropertiesEXT =
          PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandlePropertiesEXT" ) );
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+        //=== VK_EXT_fragment_density_map_offset ===
+        vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2EXT" ) );
      }

      void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
@ -21680,6 +21881,11 @@ namespace VULKAN_HPP_NAMESPACE
        vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+        //=== VK_QCOM_tile_shading ===
+        vkCmdDispatchTileQCOM          = PFN_vkCmdDispatchTileQCOM( vkGetDeviceProcAddr( device, "vkCmdDispatchTileQCOM" ) );
+        vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdBeginPerTileExecutionQCOM" ) );
+        vkCmdEndPerTileExecutionQCOM   = PFN_vkCmdEndPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdEndPerTileExecutionQCOM" ) );
+
 #if defined( VK_USE_PLATFORM_METAL_EXT )
        //=== VK_EXT_metal_objects ===
        vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) );
@ -22013,6 +22219,11 @@ namespace VULKAN_HPP_NAMESPACE
        vkCmdBindDescriptorBufferEmbeddedSamplers2EXT =
          PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );

+        //=== VK_NV_external_compute_queue ===
+        vkCreateExternalComputeQueueNV  = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) );
+        vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) );
+        vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetDeviceProcAddr( device, "vkGetExternalComputeQueueDataNV" ) );
+
        //=== VK_NV_cluster_acceleration_structure ===
        vkGetClusterAccelerationStructureBuildSizesNV =
          PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetClusterAccelerationStructureBuildSizesNV" ) );
@ -22044,6 +22255,9 @@ namespace VULKAN_HPP_NAMESPACE
        vkGetMemoryMetalHandleEXT           = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
        vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) );
 #endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+        //=== VK_EXT_fragment_density_map_offset ===
+        vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) );
      }

      template <typename DynamicLoader>
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
@ -69,7 +69,7 @@ extern "C" {
 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0

 // Version of this file
-#define VK_HEADER_VERSION 310
+#define VK_HEADER_VERSION 312

 // Complete version of this file
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -658,6 +658,7 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX = 1000134004,
 #endif
    VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR = 1000141000,
    VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
    VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
    VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
@ -877,6 +878,12 @@ typedef enum VkStructureType {
 #ifdef VK_ENABLE_BETA_EXTENSIONS
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV = 1000307004,
 #endif
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM = 1000309000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM = 1000309001,
+    VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM = 1000309002,
+    VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM = 1000309003,
+    VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM = 1000309004,
+    VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM = 1000309005,
    VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000,
    VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000,
    VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001,
@ -1024,9 +1031,6 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM = 1000424002,
    VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003,
    VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001,
-    VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000,
@ -1177,6 +1181,10 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553007,
    VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553008,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000,
+    VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV = 1000556000,
+    VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV = 1000556001,
+    VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV = 1000556002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV = 1000556003,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV = 1000559000,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR = 1000562000,
@ -1243,6 +1251,10 @@ typedef enum VkStructureType {
 #ifdef VK_ENABLE_BETA_EXTENSIONS
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001,
 #endif
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT = 1000425000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001,
+    VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002,
+    VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = 1000619003,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
  // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a deprecated alias
@ -1453,6 +1465,9 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,
+    VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES,
    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES,
@ -1588,6 +1603,7 @@ typedef enum VkObjectType {
    VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000,
    VK_OBJECT_TYPE_SHADER_EXT = 1000482000,
    VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000,
+    VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV = 1000556000,
    VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000,
    VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001,
    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
@ -2502,14 +2518,15 @@ typedef enum VkImageCreateFlagBits {
    VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000,
    VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000,
    VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000,
-    VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000,
    VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000,
+    VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 0x00008000,
    VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
    VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
    VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
+    VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT,
    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 } VkImageCreateFlagBits;
 typedef VkFlags VkImageCreateFlags;
@ -2985,6 +3002,7 @@ typedef enum VkSubpassDescriptionFlagBits {
    VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
    VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004,
    VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008,
+    VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM = 0x00000100,
    VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0x00000010,
    VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000020,
    VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000040,
@ -6884,6 +6902,8 @@ static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x8000000
 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL;
 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL;
 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL;
+static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM = 0x8000000000000ULL;
+static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM = 0x10000000000000ULL;
 static const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0ULL;
 static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL;
 static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL;
@ -10711,6 +10731,20 @@ typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
 #define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"


+// VK_KHR_shader_bfloat16 is a preprocessor guard. Do not pass it to API calls.
+#define VK_KHR_shader_bfloat16 1
+#define VK_KHR_SHADER_BFLOAT16_SPEC_VERSION 1
+#define VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME "VK_KHR_shader_bfloat16"
+typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderBFloat16Type;
+    VkBool32           shaderBFloat16DotProduct;
+    VkBool32           shaderBFloat16CooperativeMatrix;
+} VkPhysicalDeviceShaderBfloat16FeaturesKHR;
+
+
+
 // VK_KHR_relaxed_block_layout is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_relaxed_block_layout 1
 #define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
@ -12191,6 +12225,7 @@ typedef enum VkComponentTypeKHR {
    VK_COMPONENT_TYPE_UINT16_KHR = 8,
    VK_COMPONENT_TYPE_UINT32_KHR = 9,
    VK_COMPONENT_TYPE_UINT64_KHR = 10,
+    VK_COMPONENT_TYPE_BFLOAT16_KHR = 1000141000,
    VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000,
    VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001,
    VK_COMPONENT_TYPE_FLOAT_E4M3_NV = 1000491002,
@ -17154,6 +17189,85 @@ VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV(
 #endif


+// VK_QCOM_tile_shading is a preprocessor guard. Do not pass it to API calls.
+#define VK_QCOM_tile_shading 1
+#define VK_QCOM_TILE_SHADING_SPEC_VERSION 1
+#define VK_QCOM_TILE_SHADING_EXTENSION_NAME "VK_QCOM_tile_shading"
+
+typedef enum VkTileShadingRenderPassFlagBitsQCOM {
+    VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM = 0x00000001,
+    VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM = 0x00000002,
+    VK_TILE_SHADING_RENDER_PASS_FLAG_BITS_MAX_ENUM_QCOM = 0x7FFFFFFF
+} VkTileShadingRenderPassFlagBitsQCOM;
+typedef VkFlags VkTileShadingRenderPassFlagsQCOM;
+typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           tileShading;
+    VkBool32           tileShadingFragmentStage;
+    VkBool32           tileShadingColorAttachments;
+    VkBool32           tileShadingDepthAttachments;
+    VkBool32           tileShadingStencilAttachments;
+    VkBool32           tileShadingInputAttachments;
+    VkBool32           tileShadingSampledAttachments;
+    VkBool32           tileShadingPerTileDraw;
+    VkBool32           tileShadingPerTileDispatch;
+    VkBool32           tileShadingDispatchTile;
+    VkBool32           tileShadingApron;
+    VkBool32           tileShadingAnisotropicApron;
+    VkBool32           tileShadingAtomicOps;
+    VkBool32           tileShadingImageProcessing;
+} VkPhysicalDeviceTileShadingFeaturesQCOM;
+
+typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxApronSize;
+    VkBool32           preferNonCoherent;
+    VkExtent2D         tileGranularity;
+    VkExtent2D         maxTileShadingRate;
+} VkPhysicalDeviceTileShadingPropertiesQCOM;
+
+typedef struct VkRenderPassTileShadingCreateInfoQCOM {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    VkTileShadingRenderPassFlagsQCOM    flags;
+    VkExtent2D                          tileApronSize;
+} VkRenderPassTileShadingCreateInfoQCOM;
+
+typedef struct VkPerTileBeginInfoQCOM {
+    VkStructureType    sType;
+    const void*        pNext;
+} VkPerTileBeginInfoQCOM;
+
+typedef struct VkPerTileEndInfoQCOM {
+    VkStructureType    sType;
+    const void*        pNext;
+} VkPerTileEndInfoQCOM;
+
+typedef struct VkDispatchTileInfoQCOM {
+    VkStructureType    sType;
+    const void*        pNext;
+} VkDispatchTileInfoQCOM;
+
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchTileQCOM)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdEndPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM(
+    VkCommandBuffer                             commandBuffer,
+    const VkPerTileBeginInfoQCOM*               pPerTileBeginInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM(
+    VkCommandBuffer                             commandBuffer,
+    const VkPerTileEndInfoQCOM*                 pPerTileEndInfo);
+#endif
+
+
 // VK_NV_low_latency is a preprocessor guard. Do not pass it to API calls.
 #define VK_NV_low_latency 1
 #define VK_NV_LOW_LATENCY_SPEC_VERSION    1
@ -18882,26 +18996,32 @@ typedef struct VkRenderPassStripeSubmitInfoARM {

 // VK_QCOM_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls.
 #define VK_QCOM_fragment_density_map_offset 1
-#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 2
+#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 3
 #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset"
-typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           fragmentDensityMapOffset;
-} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;

-typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+
+typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
    VkStructureType    sType;
    void*              pNext;
    VkExtent2D         fragmentDensityOffsetGranularity;
-} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;

-typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM {
+typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+
+typedef struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT {
    VkStructureType      sType;
    const void*          pNext;
    uint32_t             fragmentDensityOffsetCount;
    const VkOffset2D*    pFragmentDensityOffsets;
-} VkSubpassFragmentDensityMapOffsetEndInfoQCOM;
+} VkRenderPassFragmentDensityMapOffsetEndInfoEXT;
+
+typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT VkSubpassFragmentDensityMapOffsetEndInfoQCOM;



@ -20551,6 +20671,59 @@ typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV {



+// VK_NV_external_compute_queue is a preprocessor guard. Do not pass it to API calls.
+#define VK_NV_external_compute_queue 1
+VK_DEFINE_HANDLE(VkExternalComputeQueueNV)
+#define VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME "VK_NV_external_compute_queue"
+typedef struct VkExternalComputeQueueDeviceCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           reservedExternalQueues;
+} VkExternalComputeQueueDeviceCreateInfoNV;
+
+typedef struct VkExternalComputeQueueCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkQueue            preferredQueue;
+} VkExternalComputeQueueCreateInfoNV;
+
+typedef struct VkExternalComputeQueueDataParamsNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           deviceIndex;
+} VkExternalComputeQueueDataParamsNV;
+
+typedef struct VkPhysicalDeviceExternalComputeQueuePropertiesNV {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           externalDataSize;
+    uint32_t           maxExternalQueues;
+} VkPhysicalDeviceExternalComputeQueuePropertiesNV;
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateExternalComputeQueueNV)(VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue);
+typedef void (VKAPI_PTR *PFN_vkDestroyExternalComputeQueueNV)(VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkGetExternalComputeQueueDataNV)(VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateExternalComputeQueueNV(
+    VkDevice                                    device,
+    const VkExternalComputeQueueCreateInfoNV*   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkExternalComputeQueueNV*                   pExternalQueue);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyExternalComputeQueueNV(
+    VkDevice                                    device,
+    VkExternalComputeQueueNV                    externalQueue,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkGetExternalComputeQueueDataNV(
+    VkExternalComputeQueueNV                    externalQueue,
+    VkExternalComputeQueueDataParamsNV*         params,
+    void*                                       pData);
+#endif
+
+
 // VK_NV_command_buffer_inheritance is a preprocessor guard. Do not pass it to API calls.
 #define VK_NV_command_buffer_inheritance 1
 #define VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION 1
@ -21386,6 +21559,24 @@ typedef struct VkPhysicalDevicePresentMeteringFeaturesNV {



+// VK_EXT_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls.
+#define VK_EXT_fragment_density_map_offset 1
+#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1
+#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_EXT_fragment_density_map_offset"
+typedef struct VkRenderingEndInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+} VkRenderingEndInfoEXT;
+
+typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2EXT)(VkCommandBuffer                   commandBuffer, const VkRenderingEndInfoEXT*        pRenderingEndInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkRenderingEndInfoEXT*                pRenderingEndInfo);
+#endif
+
+
 // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
 #define VK_KHR_acceleration_structure 1
 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13
--- a/include/vulkan/vulkan_enums.hpp
+++ b/include/vulkan/vulkan_enums.hpp
@ -988,6 +988,7 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
    eAttachmentSampleCountInfoAMD                      = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD,
    eAttachmentSampleCountInfoNV                       = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV,
+    ePhysicalDeviceShaderBfloat16FeaturesKHR           = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR,
    eSampleLocationsInfoEXT                            = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,
    eRenderPassSampleLocationsBeginInfoEXT             = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
    ePipelineSampleLocationsStateCreateInfoEXT         = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
@ -1208,7 +1209,13 @@ namespace VULKAN_HPP_NAMESPACE
    ePhysicalDeviceCudaKernelLaunchFeaturesNV   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV,
    ePhysicalDeviceCudaKernelLaunchPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV,
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
-    eQueryLowLatencySupportNV = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV,
+    ePhysicalDeviceTileShadingFeaturesQCOM   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM,
+    ePhysicalDeviceTileShadingPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM,
+    eRenderPassTileShadingCreateInfoQCOM     = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM,
+    ePerTileBeginInfoQCOM                    = VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM,
+    ePerTileEndInfoQCOM                      = VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM,
+    eDispatchTileInfoQCOM                    = VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM,
+    eQueryLowLatencySupportNV                = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV,
 #if defined( VK_USE_PLATFORM_METAL_EXT )
    eExportMetalObjectCreateInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT,
    eExportMetalObjectsInfoEXT      = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT,
@ -1360,9 +1367,6 @@ namespace VULKAN_HPP_NAMESPACE
    eRenderPassStripeBeginInfoARM                                = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM,
    eRenderPassStripeInfoARM                                     = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM,
    eRenderPassStripeSubmitInfoARM                               = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM,
-    ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM          = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
-    ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM        = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
-    eSubpassFragmentDensityMapOffsetEndInfoQCOM                  = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
    ePhysicalDeviceCopyMemoryIndirectFeaturesNV                  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV,
    ePhysicalDeviceCopyMemoryIndirectPropertiesNV                = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV,
    ePhysicalDeviceMemoryDecompressionFeaturesNV                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV,
@ -1522,6 +1526,10 @@ namespace VULKAN_HPP_NAMESPACE
    eVideoEncodeAv1QuantizationMapCapabilitiesKHR               = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR,
    eVideoFormatAv1QuantizationMapPropertiesKHR                 = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR,
    ePhysicalDeviceRawAccessChainsFeaturesNV                    = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV,
+    eExternalComputeQueueDeviceCreateInfoNV                     = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV,
+    eExternalComputeQueueCreateInfoNV                           = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV,
+    eExternalComputeQueueDataParamsNV                           = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV,
+    ePhysicalDeviceExternalComputeQueuePropertiesNV             = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV,
    ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR,
    ePhysicalDeviceCommandBufferInheritanceFeaturesNV           = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV,
    ePhysicalDeviceMaintenance7FeaturesKHR                      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR,
@ -1587,8 +1595,15 @@ namespace VULKAN_HPP_NAMESPACE
    ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT,
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
    eSetPresentConfigNV                      = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV,
-    ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV
+    ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV,
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
+    ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT    = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,
+    ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
+    ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,
+    ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
+    eRenderPassFragmentDensityMapOffsetEndInfoEXT         = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,
+    eSubpassFragmentDensityMapOffsetEndInfoQCOM           = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
+    eRenderingEndInfoEXT                                  = VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT
  };

  // wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html
@ -1659,6 +1674,7 @@ namespace VULKAN_HPP_NAMESPACE
    eOpticalFlowSessionNV      = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV,
    eShaderEXT                 = VK_OBJECT_TYPE_SHADER_EXT,
    ePipelineBinaryKHR         = VK_OBJECT_TYPE_PIPELINE_BINARY_KHR,
+    eExternalComputeQueueNV    = VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV,
    eIndirectCommandsLayoutEXT = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT,
    eIndirectExecutionSetEXT   = VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT
  };
@ -2087,8 +2103,9 @@ namespace VULKAN_HPP_NAMESPACE
    eDescriptorBufferCaptureReplayEXT     = VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT,
    eMultisampledRenderToSingleSampledEXT = VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT,
    e2DViewCompatibleEXT                  = VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT,
-    eFragmentDensityMapOffsetQCOM         = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM,
-    eVideoProfileIndependentKHR           = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR
+    eVideoProfileIndependentKHR           = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR,
+    eFragmentDensityMapOffsetEXT          = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT,
+    eFragmentDensityMapOffsetQCOM         = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM
  };

  // wrapper using for bitmask VkImageCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlags.html
@ -2105,7 +2122,7 @@ namespace VULKAN_HPP_NAMESPACE
      ImageCreateFlagBits::eProtected | ImageCreateFlagBits::eDisjoint | ImageCreateFlagBits::eCornerSampledNV |
      ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT | ImageCreateFlagBits::eSubsampledEXT | ImageCreateFlagBits::eDescriptorBufferCaptureReplayEXT |
      ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT | ImageCreateFlagBits::e2DViewCompatibleEXT |
-      ImageCreateFlagBits::eFragmentDensityMapOffsetQCOM | ImageCreateFlagBits::eVideoProfileIndependentKHR;
+      ImageCreateFlagBits::eVideoProfileIndependentKHR | ImageCreateFlagBits::eFragmentDensityMapOffsetEXT;
  };

  // wrapper class for enum VkImageTiling, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageTiling.html
@ -3807,6 +3824,7 @@ namespace VULKAN_HPP_NAMESPACE
    ePerViewPositionXOnlyNVX                      = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX,
    eFragmentRegionQCOM                           = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM,
    eShaderResolveQCOM                            = VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM,
+    eTileShadingApronQCOM                         = VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM,
    eRasterizationOrderAttachmentColorAccessEXT   = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT,
    eRasterizationOrderAttachmentColorAccessARM   = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM,
    eRasterizationOrderAttachmentDepthAccessEXT   = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT,
@ -3825,7 +3843,7 @@ namespace VULKAN_HPP_NAMESPACE
    static VULKAN_HPP_CONST_OR_CONSTEXPR bool                    isBitmask = true;
    static VULKAN_HPP_CONST_OR_CONSTEXPR SubpassDescriptionFlags allFlags =
      SubpassDescriptionFlagBits::ePerViewAttributesNVX | SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX |
-      SubpassDescriptionFlagBits::eFragmentRegionQCOM | SubpassDescriptionFlagBits::eShaderResolveQCOM |
+      SubpassDescriptionFlagBits::eFragmentRegionQCOM | SubpassDescriptionFlagBits::eShaderResolveQCOM | SubpassDescriptionFlagBits::eTileShadingApronQCOM |
      SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT | SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT |
      SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT | SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT;
  };
@ -4729,6 +4747,8 @@ namespace VULKAN_HPP_NAMESPACE
    eVideoDecodeWriteKHR                  = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR,
    eVideoEncodeReadKHR                   = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR,
    eVideoEncodeWriteKHR                  = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR,
+    eShaderTileAttachmentReadQCOM         = VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM,
+    eShaderTileAttachmentWriteQCOM        = VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM,
    eTransformFeedbackWriteEXT            = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
    eTransformFeedbackCounterReadEXT      = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT,
    eTransformFeedbackCounterWriteEXT     = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
@ -4772,12 +4792,13 @@ namespace VULKAN_HPP_NAMESPACE
      AccessFlagBits2::eHostWrite | AccessFlagBits2::eMemoryRead | AccessFlagBits2::eMemoryWrite | AccessFlagBits2::eShaderSampledRead |
      AccessFlagBits2::eShaderStorageRead | AccessFlagBits2::eShaderStorageWrite | AccessFlagBits2::eVideoDecodeReadKHR |
      AccessFlagBits2::eVideoDecodeWriteKHR | AccessFlagBits2::eVideoEncodeReadKHR | AccessFlagBits2::eVideoEncodeWriteKHR |
-      AccessFlagBits2::eTransformFeedbackWriteEXT | AccessFlagBits2::eTransformFeedbackCounterReadEXT | AccessFlagBits2::eTransformFeedbackCounterWriteEXT |
-      AccessFlagBits2::eConditionalRenderingReadEXT | AccessFlagBits2::eCommandPreprocessReadEXT | AccessFlagBits2::eCommandPreprocessWriteEXT |
-      AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR | AccessFlagBits2::eAccelerationStructureReadKHR |
-      AccessFlagBits2::eAccelerationStructureWriteKHR | AccessFlagBits2::eFragmentDensityMapReadEXT | AccessFlagBits2::eColorAttachmentReadNoncoherentEXT |
-      AccessFlagBits2::eDescriptorBufferReadEXT | AccessFlagBits2::eInvocationMaskReadHUAWEI | AccessFlagBits2::eShaderBindingTableReadKHR |
-      AccessFlagBits2::eMicromapReadEXT | AccessFlagBits2::eMicromapWriteEXT | AccessFlagBits2::eOpticalFlowReadNV | AccessFlagBits2::eOpticalFlowWriteNV;
+      AccessFlagBits2::eShaderTileAttachmentReadQCOM | AccessFlagBits2::eShaderTileAttachmentWriteQCOM | AccessFlagBits2::eTransformFeedbackWriteEXT |
+      AccessFlagBits2::eTransformFeedbackCounterReadEXT | AccessFlagBits2::eTransformFeedbackCounterWriteEXT | AccessFlagBits2::eConditionalRenderingReadEXT |
+      AccessFlagBits2::eCommandPreprocessReadEXT | AccessFlagBits2::eCommandPreprocessWriteEXT | AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR |
+      AccessFlagBits2::eAccelerationStructureReadKHR | AccessFlagBits2::eAccelerationStructureWriteKHR | AccessFlagBits2::eFragmentDensityMapReadEXT |
+      AccessFlagBits2::eColorAttachmentReadNoncoherentEXT | AccessFlagBits2::eDescriptorBufferReadEXT | AccessFlagBits2::eInvocationMaskReadHUAWEI |
+      AccessFlagBits2::eShaderBindingTableReadKHR | AccessFlagBits2::eMicromapReadEXT | AccessFlagBits2::eMicromapWriteEXT |
+      AccessFlagBits2::eOpticalFlowReadNV | AccessFlagBits2::eOpticalFlowWriteNV;
  };

  // wrapper class for enum VkSubmitFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlagBits.html
@ -7405,6 +7426,28 @@ namespace VULKAN_HPP_NAMESPACE
      DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints | DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting;
  };

+  //=== VK_QCOM_tile_shading ===
+
+  // wrapper class for enum VkTileShadingRenderPassFlagBitsQCOM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagBitsQCOM.html
+  enum class TileShadingRenderPassFlagBitsQCOM : VkTileShadingRenderPassFlagsQCOM
+  {
+    eEnable           = VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM,
+    ePerTileExecution = VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM
+  };
+
+  // wrapper using for bitmask VkTileShadingRenderPassFlagsQCOM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagsQCOM.html
+  using TileShadingRenderPassFlagsQCOM = Flags<TileShadingRenderPassFlagBitsQCOM>;
+
+  template <>
+  struct FlagTraits<TileShadingRenderPassFlagBitsQCOM>
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool                           isBitmask = true;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR TileShadingRenderPassFlagsQCOM allFlags =
+      TileShadingRenderPassFlagBitsQCOM::eEnable | TileShadingRenderPassFlagBitsQCOM::ePerTileExecution;
+  };
+
 #if defined( VK_USE_PLATFORM_METAL_EXT )
  //=== VK_EXT_metal_objects ===

@ -8152,6 +8195,7 @@ namespace VULKAN_HPP_NAMESPACE
    eUint16        = VK_COMPONENT_TYPE_UINT16_KHR,
    eUint32        = VK_COMPONENT_TYPE_UINT32_KHR,
    eUint64        = VK_COMPONENT_TYPE_UINT64_KHR,
+    eBfloat16      = VK_COMPONENT_TYPE_BFLOAT16_KHR,
    eSint8PackedNV = VK_COMPONENT_TYPE_SINT8_PACKED_NV,
    eUint8PackedNV = VK_COMPONENT_TYPE_UINT8_PACKED_NV,
    eFloatE4M3NV   = VK_COMPONENT_TYPE_FLOAT_E4M3_NV,
@ -8843,6 +8887,10 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR:
        return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;

+        //=== VK_NV_external_compute_queue ===
+      case VULKAN_HPP_NAMESPACE::ObjectType::eExternalComputeQueueNV:
+        return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
+
        //=== VK_EXT_device_generated_commands ===
      case VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutEXT: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
      case VULKAN_HPP_NAMESPACE::ObjectType::eIndirectExecutionSetEXT: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
--- a/include/vulkan/vulkan_extension_inspection.hpp
+++ b/include/vulkan/vulkan_extension_inspection.hpp
--- a/include/vulkan/vulkan_format_traits.hpp
+++ b/include/vulkan/vulkan_format_traits.hpp
@ -4662,7 +4662,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eB8G8R8A8Unorm:
@ -4725,7 +4725,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eA8B8G8R8UnormPack32:
@ -4785,7 +4785,7 @@ namespace VULKAN_HPP_NAMESPACE
      case VULKAN_HPP_NAMESPACE::Format::eA8B8G8R8SrgbPack32:
        switch ( component )
        {
-          case 0: return "SRGB";
+          case 0: return "UNORM";
          case 1: return "SRGB";
          case 2: return "SRGB";
          case 3: return "SRGB";
@ -5381,7 +5381,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eBc2UnormBlock:
@ -5399,7 +5399,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eBc3UnormBlock:
@ -5417,7 +5417,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eBc4UnormBlock:
@ -5477,7 +5477,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8UnormBlock:
@ -5511,7 +5511,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8UnormBlock:
@ -5529,7 +5529,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eEacR11UnormBlock:
@ -5573,7 +5573,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc5x4UnormBlock:
@ -5591,7 +5591,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc5x5UnormBlock:
@ -5609,7 +5609,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc6x5UnormBlock:
@ -5627,7 +5627,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc6x6UnormBlock:
@ -5645,7 +5645,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc8x5UnormBlock:
@ -5663,7 +5663,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc8x6UnormBlock:
@ -5681,7 +5681,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc8x8UnormBlock:
@ -5699,7 +5699,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x5UnormBlock:
@ -5717,7 +5717,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x6UnormBlock:
@ -5735,7 +5735,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x8UnormBlock:
@ -5753,7 +5753,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc10x10UnormBlock:
@ -5771,7 +5771,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x10UnormBlock:
@ -5789,7 +5789,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eAstc12x12UnormBlock:
@ -5807,7 +5807,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eG8B8G8R8422Unorm:
@ -6319,7 +6319,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG:
@ -6328,7 +6328,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG:
@ -6337,7 +6337,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG:
@ -6346,7 +6346,7 @@ namespace VULKAN_HPP_NAMESPACE
          case 0: return "SRGB";
          case 1: return "SRGB";
          case 2: return "SRGB";
-          case 3: return "SRGB";
+          case 3: return "UNORM";
          default: VULKAN_HPP_ASSERT( false ); return "";
        }
      case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV:
--- a/include/vulkan/vulkan_funcs.hpp
+++ b/include/vulkan/vulkan_funcs.hpp
@ -24930,6 +24930,66 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+
+  // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkCmdDispatchTileQCOM( static_cast<VkCommandBuffer>( m_commandBuffer ) );
+  }
+
+  // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM * pPerTileBeginInfo,
+                                                                   Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkCmdBeginPerTileExecutionQCOM( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerTileBeginInfoQCOM *>( pPerTileBeginInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM & perTileBeginInfo,
+                                                                   Dispatch const &                                   d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdBeginPerTileExecutionQCOM && "Function <vkCmdBeginPerTileExecutionQCOM> requires <VK_QCOM_tile_shading>" );
+#  endif
+
+    d.vkCmdBeginPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast<const VkPerTileBeginInfoQCOM *>( &perTileBeginInfo ) );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+  // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM * pPerTileEndInfo,
+                                                                 Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkCmdEndPerTileExecutionQCOM( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerTileEndInfoQCOM *>( pPerTileEndInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM & perTileEndInfo,
+                                                                 Dispatch const &                                 d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdEndPerTileExecutionQCOM && "Function <vkCmdEndPerTileExecutionQCOM> requires <VK_QCOM_tile_shading>" );
+#  endif
+
+    d.vkCmdEndPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast<const VkPerTileEndInfoQCOM *>( &perTileEndInfo ) );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
 #if defined( VK_USE_PLATFORM_METAL_EXT )
  //=== VK_EXT_metal_objects ===

@ -30717,6 +30777,177 @@ namespace VULKAN_HPP_NAMESPACE
  }
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

+  //=== VK_NV_external_compute_queue ===
+
+  // wrapper function for command vkCreateExternalComputeQueueNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result
+    Device::createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV * pCreateInfo,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+                                          VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV *                 pExternalQueue,
+                                          Dispatch const &                                               d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    return static_cast<Result>( d.vkCreateExternalComputeQueueNV( static_cast<VkDevice>( m_device ),
+                                                                  reinterpret_cast<const VkExternalComputeQueueCreateInfoNV *>( pCreateInfo ),
+                                                                  reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ),
+                                                                  reinterpret_cast<VkExternalComputeQueueNV *>( pExternalQueue ) ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkCreateExternalComputeQueueNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>::type
+                       Device::createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV & createInfo,
+                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>      allocator,
+                                          Dispatch const &                                               d ) const
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function <vkCreateExternalComputeQueueNV> requires <VK_NV_external_compute_queue>" );
+#  endif
+
+    VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue;
+    VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExternalComputeQueueNV(
+      m_device,
+      reinterpret_cast<const VkExternalComputeQueueCreateInfoNV *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkExternalComputeQueueNV *>( &externalQueue ) ) );
+    VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNV" );
+
+    return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( externalQueue ) );
+  }
+
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+  // wrapper function for command vkCreateExternalComputeQueueNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
+  template <typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV, Dispatch>>::type
+                       Device::createExternalComputeQueueNVUnique( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV & createInfo,
+                                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks>      allocator,
+                                                Dispatch const &                                               d ) const
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#    if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function <vkCreateExternalComputeQueueNV> requires <VK_NV_external_compute_queue>" );
+#    endif
+
+    VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue;
+    VULKAN_HPP_NAMESPACE::Result                 result = static_cast<VULKAN_HPP_NAMESPACE::Result>( d.vkCreateExternalComputeQueueNV(
+      m_device,
+      reinterpret_cast<const VkExternalComputeQueueCreateInfoNV *>( &createInfo ),
+      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
+      reinterpret_cast<VkExternalComputeQueueNV *>( &externalQueue ) ) );
+    VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNVUnique" );
+
+    return VULKAN_HPP_NAMESPACE::detail::createResultValueType(
+      result,
+      UniqueHandle<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV, Dispatch>( externalQueue, detail::ObjectDestroy<Device, Dispatch>( *this, allocator, d ) ) );
+  }
+#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
+#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+  // wrapper function for command vkDestroyExternalComputeQueueNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV      externalQueue,
+                                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                                                Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkDestroyExternalComputeQueueNV( static_cast<VkDevice>( m_device ),
+                                       static_cast<VkExternalComputeQueueNV>( externalQueue ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkDestroyExternalComputeQueueNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV              externalQueue,
+                                                                Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
+                                                                Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function <vkDestroyExternalComputeQueueNV> requires <VK_NV_external_compute_queue>" );
+#  endif
+
+    d.vkDestroyExternalComputeQueueNV(
+      m_device,
+      static_cast<VkExternalComputeQueueNV>( externalQueue ),
+      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+  // wrapper function for command vkDestroyExternalComputeQueueNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV      externalQueue,
+                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                          Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkDestroyExternalComputeQueueNV( static_cast<VkDevice>( m_device ),
+                                       static_cast<VkExternalComputeQueueNV>( externalQueue ),
+                                       reinterpret_cast<const VkAllocationCallbacks *>( pAllocator ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkDestroyExternalComputeQueueNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV              externalQueue,
+                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator,
+                                          Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function <vkDestroyExternalComputeQueueNV> requires <VK_NV_external_compute_queue>" );
+#  endif
+
+    d.vkDestroyExternalComputeQueueNV(
+      m_device,
+      static_cast<VkExternalComputeQueueNV>( externalQueue ),
+      reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+  // wrapper function for command vkGetExternalComputeQueueDataNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void ExternalComputeQueueNV::getData( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV * params,
+                                                          void *                                                   pData,
+                                                          Dispatch const &                                         d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkGetExternalComputeQueueDataNV(
+      static_cast<VkExternalComputeQueueNV>( m_externalComputeQueueNV ), reinterpret_cast<VkExternalComputeQueueDataParamsNV *>( params ), pData );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkGetExternalComputeQueueDataNV, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
+  template <typename DataType, typename Dispatch>
+  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV, DataType>
+                                         ExternalComputeQueueNV::getData( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkGetExternalComputeQueueDataNV && "Function <vkGetExternalComputeQueueDataNV> requires <VK_NV_external_compute_queue>" );
+#  endif
+
+    std::pair<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV, DataType> data_;
+    VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV &                    arams = data_.first;
+    DataType &                                                                  data  = data_.second;
+    d.vkGetExternalComputeQueueDataNV( m_externalComputeQueueNV, reinterpret_cast<VkExternalComputeQueueDataParamsNV *>( &arams ), &data );
+
+    return data_;
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
  //=== VK_NV_cluster_acceleration_structure ===

  // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see
@ -31501,5 +31732,32 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 #endif   /*VK_USE_PLATFORM_METAL_EXT*/

+  //=== VK_EXT_fragment_density_map_offset ===
+
+  // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT * pRenderingEndInfo,
+                                                          Dispatch const &                                  d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+    d.vkCmdEndRendering2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingEndInfoEXT *>( pRenderingEndInfo ) );
+  }
+
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+  // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
+  template <typename Dispatch>
+  VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo,
+                                                          Dispatch const &                                          d ) const VULKAN_HPP_NOEXCEPT
+  {
+    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
+#  if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
+    VULKAN_HPP_ASSERT( d.vkCmdEndRendering2EXT && "Function <vkCmdEndRendering2EXT> requires <VK_EXT_fragment_density_map_offset>" );
+#  endif
+
+    d.vkCmdEndRendering2EXT(
+      m_commandBuffer, reinterpret_cast<const VkRenderingEndInfoEXT *>( static_cast<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT *>( renderingEndInfo ) ) );
+  }
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
 }  // namespace VULKAN_HPP_NAMESPACE
 #endif
--- a/include/vulkan/vulkan_handles.hpp
+++ b/include/vulkan/vulkan_handles.hpp
@ -949,6 +949,9 @@ namespace VULKAN_HPP_NAMESPACE
  struct AttachmentSampleCountInfoAMD;
  using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;

+  //=== VK_KHR_shader_bfloat16 ===
+  struct PhysicalDeviceShaderBfloat16FeaturesKHR;
+
  //=== VK_EXT_sample_locations ===
  struct SampleLocationEXT;
  struct SampleLocationsInfoEXT;
@ -1347,6 +1350,14 @@ namespace VULKAN_HPP_NAMESPACE
  struct PhysicalDeviceCudaKernelLaunchPropertiesNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_QCOM_tile_shading ===
+  struct PhysicalDeviceTileShadingFeaturesQCOM;
+  struct PhysicalDeviceTileShadingPropertiesQCOM;
+  struct RenderPassTileShadingCreateInfoQCOM;
+  struct PerTileBeginInfoQCOM;
+  struct PerTileEndInfoQCOM;
+  struct DispatchTileInfoQCOM;
+
  //=== VK_NV_low_latency ===
  struct QueryLowLatencySupportNV;

@ -1628,11 +1639,6 @@ namespace VULKAN_HPP_NAMESPACE
  struct RenderPassStripeInfoARM;
  struct RenderPassStripeSubmitInfoARM;

-  //=== VK_QCOM_fragment_density_map_offset ===
-  struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
-  struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
-  struct SubpassFragmentDensityMapOffsetEndInfoQCOM;
-
  //=== VK_NV_copy_memory_indirect ===
  struct CopyMemoryIndirectCommandNV;
  struct CopyMemoryToImageIndirectCommandNV;
@ -1917,6 +1923,12 @@ namespace VULKAN_HPP_NAMESPACE
  //=== VK_NV_raw_access_chains ===
  struct PhysicalDeviceRawAccessChainsFeaturesNV;

+  //=== VK_NV_external_compute_queue ===
+  struct ExternalComputeQueueDeviceCreateInfoNV;
+  struct ExternalComputeQueueCreateInfoNV;
+  struct ExternalComputeQueueDataParamsNV;
+  struct PhysicalDeviceExternalComputeQueuePropertiesNV;
+
  //=== VK_KHR_shader_relaxed_extended_instruction ===
  struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;

@ -2046,6 +2058,15 @@ namespace VULKAN_HPP_NAMESPACE
  struct PhysicalDevicePresentMeteringFeaturesNV;
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+  //=== VK_EXT_fragment_density_map_offset ===
+  struct RenderingEndInfoEXT;
+  struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
+  using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
+  struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
+  using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
+  struct RenderPassFragmentDensityMapOffsetEndInfoEXT;
+  using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT;
+
  //===================================
  //=== HANDLE forward declarations ===
  //===================================
@ -2149,6 +2170,9 @@ namespace VULKAN_HPP_NAMESPACE
  //=== VK_KHR_pipeline_binary ===
  class PipelineBinaryKHR;

+  //=== VK_NV_external_compute_queue ===
+  class ExternalComputeQueueNV;
+
  //=== VK_EXT_device_generated_commands ===
  class IndirectCommandsLayoutEXT;
  class IndirectExecutionSetEXT;
@ -2621,6 +2645,16 @@ namespace VULKAN_HPP_NAMESPACE

  using UniquePipelineBinaryKHR = UniqueHandle<PipelineBinaryKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;

+  //=== VK_NV_external_compute_queue ===
+  template <typename Dispatch>
+  class UniqueHandleTraits<ExternalComputeQueueNV, Dispatch>
+  {
+  public:
+    using deleter = detail::ObjectDestroy<Device, Dispatch>;
+  };
+
+  using UniqueExternalComputeQueueNV = UniqueHandle<ExternalComputeQueueNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
+
  //=== VK_EXT_device_generated_commands ===
  template <typename Dispatch>
  class UniqueHandleTraits<IndirectCommandsLayoutEXT, Dispatch>
@ -6858,6 +6892,38 @@ namespace VULKAN_HPP_NAMESPACE
 #  endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/

+    //=== VK_QCOM_tile_shading ===
+
+    // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void dispatchTileQCOM( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
+    // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM * pPerTileBeginInfo,
+                                    Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM & perTileBeginInfo,
+                                    Dispatch const & d                                 VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+    // wrapper function for command vkCmdEndPerTileExecutionQCOM, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM * pPerTileEndInfo,
+                                  Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkCmdEndPerTileExecutionQCOM, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM & perTileEndInfo,
+                                  Dispatch const & d                               VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
    //=== VK_KHR_synchronization2 ===

    // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html
@ -7797,6 +7863,19 @@ namespace VULKAN_HPP_NAMESPACE
                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

+    //=== VK_EXT_fragment_density_map_offset ===
+
+    // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void endRendering2EXT( const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT * pRenderingEndInfo,
+                           Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void endRendering2EXT( Optional<const VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT> renderingEndInfo VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
    operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
    {
      return m_commandBuffer;
@ -9063,6 +9142,110 @@ namespace VULKAN_HPP_NAMESPACE
    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
  };

+  // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html
+  class ExternalComputeQueueNV
+  {
+  public:
+    using CType      = VkExternalComputeQueueNV;
+    using NativeType = VkExternalComputeQueueNV;
+
+    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eExternalComputeQueueNV;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
+      VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
+
+  public:
+    ExternalComputeQueueNV() VULKAN_HPP_NOEXCEPT {}  // = default; - try to workaround a compiler issue
+
+    ExternalComputeQueueNV( ExternalComputeQueueNV const & rhs )             = default;
+    ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & rhs ) = default;
+
+#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE )
+    ExternalComputeQueueNV( ExternalComputeQueueNV && rhs )             = default;
+    ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) = default;
+#else
+    ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT
+      : m_externalComputeQueueNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_externalComputeQueueNV, {} ) )
+    {
+    }
+
+    ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      m_externalComputeQueueNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_externalComputeQueueNV, {} );
+      return *this;
+    }
+#endif
+
+    VULKAN_HPP_CONSTEXPR ExternalComputeQueueNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
+
+    ExternalComputeQueueNV( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( externalComputeQueueNV ) {}
+
+    ExternalComputeQueueNV & operator=( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT
+    {
+      m_externalComputeQueueNV = externalComputeQueueNV;
+      return *this;
+    }
+
+    ExternalComputeQueueNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
+    {
+      m_externalComputeQueueNV = {};
+      return *this;
+    }
+
+    //=== VK_NV_external_compute_queue ===
+
+    // wrapper function for command vkGetExternalComputeQueueDataNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void getData( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV * params,
+                  void *                                                   pData,
+                  Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkGetExternalComputeQueueDataNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html
+    template <typename DataType, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV, DataType>
+                         getData( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+    operator VkExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_externalComputeQueueNV;
+    }
+
+    explicit operator bool() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_externalComputeQueueNV != VK_NULL_HANDLE;
+    }
+
+    bool operator!() const VULKAN_HPP_NOEXCEPT
+    {
+      return m_externalComputeQueueNV == VK_NULL_HANDLE;
+    }
+
+  private:
+    VkExternalComputeQueueNV m_externalComputeQueueNV = {};
+  };
+
+  template <>
+  struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eExternalComputeQueueNV>
+  {
+    using Type = VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV;
+  };
+
+#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
+  template <>
+  struct CppType<VkExternalComputeQueueNV, VK_NULL_HANDLE>
+  {
+    using Type = VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV;
+  };
+#endif
+
+  template <>
+  struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
+  };
+
  // wrapper class for handle VkFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebuffer.html
  class Framebuffer
  {
@ -17160,6 +17343,64 @@ namespace VULKAN_HPP_NAMESPACE
                                 Dispatch const & d                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

+    //=== VK_NV_external_compute_queue ===
+
+    // wrapper function for command vkCreateExternalComputeQueueNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD Result createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV * pCreateInfo,
+                                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
+                                                              VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV *                 pExternalQueue,
+                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkCreateExternalComputeQueueNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>::type
+      createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV &      createInfo,
+                                    Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                    Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  ifndef VULKAN_HPP_NO_SMART_HANDLE
+    // wrapper function for command vkCreateExternalComputeQueueNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    VULKAN_HPP_NODISCARD typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV, Dispatch>>::type
+      createExternalComputeQueueNVUnique( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV &      createInfo,
+                                          Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                          Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
+#  endif /* VULKAN_HPP_NO_SMART_HANDLE */
+#endif   /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+    // wrapper function for command vkDestroyExternalComputeQueueNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV      externalQueue,
+                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                                        Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkDestroyExternalComputeQueueNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV                        externalQueue,
+                                        Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
+    // wrapper function for command vkDestroyExternalComputeQueueNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV      externalQueue,
+                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
+                  Dispatch const & d                                VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
+    // wrapper function for command vkDestroyExternalComputeQueueNV, see
+    // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html
+    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
+    void destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV                        externalQueue,
+                  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                  Dispatch const & d                                                  VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
+
    //=== VK_NV_cluster_acceleration_structure ===

    // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see
--- a/include/vulkan/vulkan_hash.hpp
+++ b/include/vulkan/vulkan_hash.hpp
@ -536,6 +536,17 @@ namespace std
    }
  };

+  //=== VK_NV_external_compute_queue ===
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const & externalComputeQueueNV ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkExternalComputeQueueNV>{}( static_cast<VkExternalComputeQueueNV>( externalComputeQueueNV ) );
+    }
+  };
+
  //=== VK_EXT_device_generated_commands ===

  template <>
@ -4512,6 +4523,18 @@ namespace std
    }
  };

+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM const & dispatchTileInfoQCOM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.pNext );
+      return seed;
+    }
+  };
+
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT>
  {
@ -5243,6 +5266,46 @@ namespace std
    }
  };

+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV const & externalComputeQueueCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.preferredQueue );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV const & externalComputeQueueDataParamsNV ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.deviceIndex );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV const & externalComputeQueueDeviceCreateInfoNV ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.reservedExternalQueues );
+      return seed;
+    }
+  };
+
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties>
  {
@ -8033,6 +8096,30 @@ namespace std
    }
  };

+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM const & perTileBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.pNext );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM const & perTileEndInfoQCOM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.pNext );
+      return seed;
+    }
+  };
+
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL>
  {
@ -9536,6 +9623,21 @@ namespace std
    }
  };

+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV const & physicalDeviceExternalComputeQueuePropertiesNV ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.externalDataSize );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.maxExternalQueues );
+      return seed;
+    }
+  };
+
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo>
  {
@ -9761,30 +9863,30 @@ namespace std
  };

  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>
  {
-    std::size_t
-      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & physicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) const
-      VULKAN_HPP_NOEXCEPT
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & physicalDeviceFragmentDensityMapOffsetFeaturesEXT )
+      const VULKAN_HPP_NOEXCEPT
    {
      std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.fragmentDensityMapOffset );
      return seed;
    }
  };

  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>
  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &
-                              physicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & physicalDeviceFragmentDensityMapOffsetPropertiesEXT ) const
+      VULKAN_HPP_NOEXCEPT
    {
      std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.fragmentDensityOffsetGranularity );
      return seed;
    }
  };
@ -12371,6 +12473,22 @@ namespace std
    }
  };

+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR const & physicalDeviceShaderBfloat16FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16Type );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16DotProduct );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16CooperativeMatrix );
+      return seed;
+    }
+  };
+
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
  {
@ -13179,6 +13297,50 @@ namespace std
    }
  };

+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM const & physicalDeviceTileShadingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShading );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingFragmentStage );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingColorAttachments );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDepthAttachments );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingStencilAttachments );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingInputAttachments );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingSampledAttachments );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDraw );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDispatch );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDispatchTile );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingApron );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAnisotropicApron );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAtomicOps );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingImageProcessing );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM const & physicalDeviceTileShadingPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxApronSize );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.preferNonCoherent );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.tileGranularity );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxTileShadingRate );
+      return seed;
+    }
+  };
+
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures>
  {
@ -15482,6 +15644,21 @@ namespace std
    }
  };

+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT const & renderPassFragmentDensityMapOffsetEndInfoEXT ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.fragmentDensityOffsetCount );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pFragmentDensityOffsets );
+      return seed;
+    }
+  };
+
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
  {
@ -15631,6 +15808,20 @@ namespace std
    }
  };

+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM const & renderPassTileShadingCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.flags );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.tileApronSize );
+      return seed;
+    }
+  };
+
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM>
  {
@ -15675,6 +15866,18 @@ namespace std
    }
  };

+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT const & renderingEndInfoEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.pNext );
+      return seed;
+    }
+  };
+
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
  {
@ -16407,21 +16610,6 @@ namespace std
    }
  };

-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const & subpassFragmentDensityMapOffsetEndInfoQCOM ) const
-      VULKAN_HPP_NOEXCEPT
-    {
-      std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount );
-      VULKAN_HPP_HASH_COMBINE( seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets );
-      return seed;
-    }
-  };
-
  template <>
  struct hash<VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT>
  {
--- a/include/vulkan/vulkan_raii.hpp
+++ b/include/vulkan/vulkan_raii.hpp
--- a/include/vulkan/vulkan_shared.hpp
+++ b/include/vulkan/vulkan_shared.hpp
@ -981,6 +981,17 @@ namespace VULKAN_HPP_NAMESPACE

  using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>;

+  //=== VK_NV_external_compute_queue ===
+  template <>
+  class SharedHandleTraits<ExternalComputeQueueNV>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::ObjectDestroyShared<ExternalComputeQueueNV>;
+  };
+
+  using SharedExternalComputeQueueNV = SharedHandle<ExternalComputeQueueNV>;
+
  //=== VK_EXT_device_generated_commands ===
  template <>
  class SharedHandleTraits<IndirectCommandsLayoutEXT>
--- a/include/vulkan/vulkan_static_assertions.hpp
+++ b/include/vulkan/vulkan_static_assertions.hpp
@ -3611,6 +3611,15 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Attachme
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>::value,
                          "AttachmentSampleCountInfoAMD is not nothrow_move_constructible!" );

+//=== VK_KHR_shader_bfloat16 ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderBfloat16FeaturesKHR ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR>::value,
+                          "PhysicalDeviceShaderBfloat16FeaturesKHR is not nothrow_move_constructible!" );
+
 //=== VK_EXT_sample_locations ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
@ -5393,6 +5402,44 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
                          "PhysicalDeviceCudaKernelLaunchPropertiesNV is not nothrow_move_constructible!" );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+//=== VK_QCOM_tile_shading ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM ) == sizeof( VkPhysicalDeviceTileShadingFeaturesQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM>::value,
+                          "PhysicalDeviceTileShadingFeaturesQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileShadingPropertiesQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM>::value,
+                          "PhysicalDeviceTileShadingPropertiesQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM ) == sizeof( VkRenderPassTileShadingCreateInfoQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM>::value,
+                          "RenderPassTileShadingCreateInfoQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM ) == sizeof( VkPerTileBeginInfoQCOM ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM>::value,
+                          "PerTileBeginInfoQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM ) == sizeof( VkPerTileEndInfoQCOM ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM>::value,
+                          "PerTileEndInfoQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM ) == sizeof( VkDispatchTileInfoQCOM ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM>::value,
+                          "DispatchTileInfoQCOM is not nothrow_move_constructible!" );
+
 //=== VK_NV_low_latency ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV ) == sizeof( VkQueryLowLatencySupportNV ),
@ -6595,31 +6642,6 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPa
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM>::value,
                          "RenderPassStripeSubmitInfoARM is not nothrow_move_constructible!" );

-//=== VK_QCOM_fragment_density_map_offset ===
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ) ==
-                            sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>::value,
-                          "PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM is not nothrow_move_constructible!" );
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ) ==
-                            sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>::value,
-                          "PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM is not nothrow_move_constructible!" );
-
-VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM ) == sizeof( VkSubpassFragmentDensityMapOffsetEndInfoQCOM ),
-                          "struct and wrapper have different size!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
-                          "struct wrapper is not a standard layout!" );
-VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>::value,
-                          "SubpassFragmentDensityMapOffsetEndInfoQCOM is not nothrow_move_constructible!" );
-
 //=== VK_NV_copy_memory_indirect ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV ) == sizeof( VkCopyMemoryIndirectCommandNV ),
@ -7881,6 +7903,42 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV>::value,
                          "PhysicalDeviceRawAccessChainsFeaturesNV is not nothrow_move_constructible!" );

+//=== VK_NV_external_compute_queue ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV ) == sizeof( VkExternalComputeQueueNV ),
+                          "handle and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>::value,
+                          "ExternalComputeQueueNV is not copy_constructible!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV>::value,
+                          "ExternalComputeQueueNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV ) == sizeof( VkExternalComputeQueueDeviceCreateInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV>::value,
+                          "ExternalComputeQueueDeviceCreateInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV ) == sizeof( VkExternalComputeQueueCreateInfoNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV>::value,
+                          "ExternalComputeQueueCreateInfoNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV ) == sizeof( VkExternalComputeQueueDataParamsNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV>::value,
+                          "ExternalComputeQueueDataParamsNV is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV ) ==
+                            sizeof( VkPhysicalDeviceExternalComputeQueuePropertiesNV ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV>::value,
+                          "PhysicalDeviceExternalComputeQueuePropertiesNV is not nothrow_move_constructible!" );
+
 //=== VK_KHR_shader_relaxed_extended_instruction ===

 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) ==
@ -8547,4 +8605,35 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPAC
                          "PhysicalDevicePresentMeteringFeaturesNV is not nothrow_move_constructible!" );
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/

+//=== VK_EXT_fragment_density_map_offset ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT ) == sizeof( VkRenderingEndInfoEXT ), "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value, "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>::value,
+                          "RenderingEndInfoEXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ) ==
+                            sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>::value,
+                          "PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ) ==
+                            sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>::value,
+                          "PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT ) ==
+                            sizeof( VkRenderPassFragmentDensityMapOffsetEndInfoEXT ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT>::value,
+                          "RenderPassFragmentDensityMapOffsetEndInfoEXT is not nothrow_move_constructible!" );
+
 #endif
--- a/include/vulkan/vulkan_structs.hpp
+++ b/include/vulkan/vulkan_structs.hpp
--- a/include/vulkan/vulkan_to_string.hpp
+++ b/include/vulkan/vulkan_to_string.hpp
--- a/registry/base_generator.py
+++ b/registry/base_generator.py
@ -541,11 +541,12 @@ class BaseGenerator(OutputGenerator):

                negative = elem.get('dir') is not None
                protect = elem.get('protect')
+                (valueInt, valueStr) = self.enumToValue(elem, True, bitwidth)

                # Some values have multiple extensions (ex VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
                # genGroup() lists them twice
                if next((x for x in fields if x.name == fieldName), None) is None:
-                    fields.append(EnumField(fieldName, negative, protect, []))
+                    fields.append(EnumField(fieldName, protect, negative, valueInt, valueStr, []))

            self.vk.enums[groupName] = Enum(groupName, [], groupProtect, bitwidth, True, fields, [], [])

@ -561,19 +562,19 @@ class BaseGenerator(OutputGenerator):
                    self.flagAliasMap[flagName] = elem.get('alias')
                    continue

-                flagMultiBit = False
-                flagZero = False
-                flagValue = intIfGet(elem, 'bitpos')
-                if flagValue is None:
-                    flagValue = intIfGet(elem, 'value')
-                    flagMultiBit = flagValue != 0
-                    flagZero = flagValue == 0
                protect = elem.get('protect')

+                (valueInt, valueStr) = self.enumToValue(elem, True, bitwidth)
+                flagZero = valueInt == 0
+                flagMultiBit = False
+                # if flag uses 'value' instead of 'bitpos', will be zero or a mask
+                if elem.get('bitpos') is None and elem.get('value'):
+                    flagMultiBit = valueInt != 0
+
                # Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
                # genGroup() lists them twice
                if next((x for x in fields if x.name == flagName), None) is None:
-                    fields.append(Flag(flagName, protect, flagValue, flagMultiBit, flagZero, []))
+                    fields.append(Flag(flagName, protect, valueInt, valueStr, flagMultiBit, flagZero, []))

            flagName = groupName.replace('FlagBits', 'Flags')
            self.vk.bitmasks[groupName] = Bitmask(groupName, [], flagName, groupProtect, bitwidth, True, fields, [], [])
--- a/registry/cgenerator.py
+++ b/registry/cgenerator.py
@ -242,7 +242,7 @@ class COutputGenerator(OutputGenerator):
                    raise MissingGeneratorOptionsError()
                if self.genOpts.conventions is None:
                    raise MissingGeneratorOptionsConventionsError()
-                is_core = self.featureName and self.featureName.startswith(self.conventions.api_prefix + 'VERSION_')
+                is_core = self.featureName and self.featureName.startswith(f"{self.conventions.api_prefix}VERSION_")
                if self.genOpts.conventions.writeFeature(self.featureName, self.featureExtraProtect, self.genOpts.filename):
                    self.newline()
                    if self.genOpts.protectFeature:
@ -340,7 +340,7 @@ class COutputGenerator(OutputGenerator):
            # OpenXR: this section was not under 'else:' previously, just fell through
            if alias:
                # If the type is an alias, just emit a typedef declaration
-                body += 'typedef ' + alias + ' ' + name + ';\n'
+                body += f"typedef {alias} {name};\n"
            else:
                # Replace <apientry /> tags with an APIENTRY-style string
                # (from self.genOpts). Copy other text through unchanged.
@ -373,13 +373,13 @@ class COutputGenerator(OutputGenerator):

        if ',' in protect_str:
            protect_list = protect_str.split(',')
-            protect_defs = ('defined(%s)' % d for d in protect_list)
+            protect_defs = (f'defined({d})' for d in protect_list)
            protect_def_str = ' && '.join(protect_defs)
-            protect_if_str = '#if %s\n' % protect_def_str
-            protect_end_str = '#endif // %s\n' % protect_def_str
+            protect_if_str = f'#if {protect_def_str}\n'
+            protect_end_str = f'#endif // {protect_def_str}\n'
        else:
-            protect_if_str = '#ifdef %s\n' % protect_str
-            protect_end_str = '#endif // %s\n' % protect_str
+            protect_if_str = f'#ifdef {protect_str}\n'
+            protect_end_str = f'#endif // {protect_str}\n'

        return (protect_if_str, protect_end_str)

@ -423,7 +423,7 @@ class COutputGenerator(OutputGenerator):
        body = self.deprecationComment(typeElem)

        if alias:
-            body += 'typedef ' + alias + ' ' + typeName + ';\n'
+            body += f"typedef {alias} {typeName};\n"
        else:
            (protect_begin, protect_end) = self.genProtectString(typeElem.get('protect'))
            if protect_begin:
@ -431,24 +431,24 @@ class COutputGenerator(OutputGenerator):

            if self.genOpts.genStructExtendsComment:
                structextends = typeElem.get('structextends')
-                body += '// ' + typeName + ' extends ' + structextends + '\n' if structextends else ''
+                body += f"// {typeName} extends {structextends}\n" if structextends else ''

-            body += 'typedef ' + typeElem.get('category')
+            body += f"typedef {typeElem.get('category')}"

            # This is an OpenXR-specific alternative where aliasing refers
            # to an inheritance hierarchy of types rather than C-level type
            # aliases.
            if self.genOpts.genAliasMacro and self.typeMayAlias(typeName):
-                body += ' ' + self.genOpts.aliasMacro
+                body += f" {self.genOpts.aliasMacro}"

-            body += ' ' + typeName + ' {\n'
+            body += f" {typeName} {{\n"

            targetLen = self.getMaxCParamTypeLength(typeinfo)
            for member in typeElem.findall('.//member'):
                body += self.deprecationComment(member, indent = 4)
                body += self.makeCParamDecl(member, targetLen + 4)
                body += ';\n'
-            body += '} ' + typeName + ';\n'
+            body += f"}} {typeName};\n"
            if protect_end:
                body += protect_end

@ -474,13 +474,13 @@ class COutputGenerator(OutputGenerator):
        if alias:
            # If the group name is aliased, just emit a typedef declaration
            # for the alias.
-            body = 'typedef ' + alias + ' ' + groupName + ';\n'
+            body = f"typedef {alias} {groupName};\n"
            self.appendSection(section, body)
        else:
            if self.genOpts is None:
                raise MissingGeneratorOptionsError()
            (section, body) = self.buildEnumCDecl(self.genOpts.genEnumBeginEndRange, groupinfo, groupName)
-            self.appendSection(section, '\n' + body)
+            self.appendSection(section, f"\n{body}")

    def genEnum(self, enuminfo, name, alias):
        """Generate the C declaration for a constant (a single <enum> value).
@ -507,7 +507,7 @@ class COutputGenerator(OutputGenerator):

        prefix = ''
        decls = self.makeCDecls(cmdinfo.elem)
-        self.appendSection('command', prefix + decls[0] + '\n')
+        self.appendSection('command', f"{prefix + decls[0]}\n")
        if self.genOpts.genFuncPointers:
            self.appendSection('commandPointer', decls[1])

--- a/registry/generator.py
+++ b/registry/generator.py
@ -116,7 +116,7 @@ class MissingGeneratorOptionsError(RuntimeError):
    def __init__(self, msg=None):
        full_msg = 'Missing generator options object self.genOpts'
        if msg:
-            full_msg += ': ' + msg
+            full_msg += f": {msg}"
        super().__init__(full_msg)


@ -126,7 +126,7 @@ class MissingRegistryError(RuntimeError):
    def __init__(self, msg=None):
        full_msg = 'Missing Registry object self.registry'
        if msg:
-            full_msg += ': ' + msg
+            full_msg += f": {msg}"
        super().__init__(full_msg)


@ -136,7 +136,7 @@ class MissingGeneratorOptionsConventionsError(RuntimeError):
    def __init__(self, msg=None):
        full_msg = 'Missing Conventions object self.genOpts.conventions'
        if msg:
-            full_msg += ': ' + msg
+            full_msg += f": {msg}"
        super().__init__(full_msg)


@ -338,7 +338,7 @@ class OutputGenerator:
        )

        if name in bad and True:
-            print('breakName {}: {}'.format(name, msg))
+            print(f'breakName {name}: {msg}')
            pdb.set_trace()

    def __init__(self, errFile=sys.stderr, warnFile=sys.stderr, diagFile=sys.stdout):
@ -399,7 +399,7 @@ class OutputGenerator:
                write('DIAG:', *args, file=self.diagFile)
        else:
            raise UserWarning(
-                '*** FATAL ERROR in Generator.logMsg: unknown level:' + level)
+                f"*** FATAL ERROR in Generator.logMsg: unknown level:{level}")

    def enumToValue(self, elem, needsNum, bitwidth = 32,
                    forceSuffix = False, parent_for_alias_dereference=None):
@ -452,20 +452,20 @@ class OutputGenerator:
            #     value += enuminfo.type
            if forceSuffix:
              if bitwidth == 64:
-                value = value + 'ULL'
+                value = f"{value}ULL"
              else:
-                value = value + 'U'
+                value = f"{value}U"
            self.logMsg('diag', 'Enum', name, '-> value [', numVal, ',', value, ']')
            return [numVal, value]
        if 'bitpos' in elem.keys():
            value = elem.get('bitpos')
            bitpos = int(value, 0)
            numVal = 1 << bitpos
-            value = '0x%08x' % numVal
+            value = f'0x{numVal:08x}'
            if bitwidth == 64 or bitpos >= 32:
-              value = value + 'ULL'
+              value = f"{value}ULL"
            elif forceSuffix:
-              value = value + 'U'
+              value = f"{value}U"
            self.logMsg('diag', 'Enum', name, '-> bitpos [', numVal, ',', value, ']')
            return [numVal, value]
        if 'offset' in elem.keys():
@ -655,12 +655,12 @@ class OutputGenerator:
        flagTypeName = groupElem.get('name')

        # Prefix
-        body = "// Flag bits for " + flagTypeName + "\n"
+        body = f"// Flag bits for {flagTypeName}\n"

        if bitwidth == 64:
-            body += "typedef VkFlags64 %s;\n" % flagTypeName;
+            body += f"typedef VkFlags64 {flagTypeName};\n";
        else:
-            body += "typedef VkFlags %s;\n" % flagTypeName;
+            body += f"typedef VkFlags {flagTypeName};\n";

        # Maximum allowable value for a flag (unsigned 64-bit integer)
        maxValidValue = 2**(64) - 1
@ -697,25 +697,25 @@ class OutputGenerator:
            if self.isEnumRequired(elem):
                protect = elem.get('protect')
                if protect is not None:
-                    body += '#ifdef {}\n'.format(protect)
+                    body += f'#ifdef {protect}\n'

                body += self.deprecationComment(elem, indent = 0)

                if usedefine:
-                    decl += "#define {} {}\n".format(name, strVal)
+                    decl += f"#define {name} {strVal}\n"
                elif self.misracppstyle():
-                    decl += "static constexpr {} {} {{{}}};\n".format(flagTypeName, name, strVal)
+                    decl += f"static constexpr {flagTypeName} {name} {{{strVal}}};\n"
                else:
                    # Some C compilers only allow initializing a 'static const' variable with a literal value.
                    # So initializing an alias from another 'static const' value would fail to compile.
                    # Work around this by chasing the aliases to get the actual value.
                    while numVal is None:
-                        alias = self.registry.tree.find("enums/enum[@name='" + strVal + "']")
+                        alias = self.registry.tree.find(f"enums/enum[@name='{strVal}']")
                        if alias is not None:
                            (numVal, strVal) = self.enumToValue(alias, True, bitwidth, True)
                        else:
-                            self.logMsg('error', 'No such alias {} for enum {}'.format(strVal, name))
-                    decl += "static const {} {} = {};\n".format(flagTypeName, name, strVal)
+                            self.logMsg('error', f'No such alias {strVal} for enum {name}')
+                    decl += f"static const {flagTypeName} {name} = {strVal};\n"

                if numVal is not None:
                    body += decl
@ -743,7 +743,7 @@ class OutputGenerator:
        expandSuffix = ''
        expandSuffixMatch = re.search(r'[A-Z][A-Z]+$', groupName)
        if expandSuffixMatch:
-            expandSuffix = '_' + expandSuffixMatch.group()
+            expandSuffix = f"_{expandSuffixMatch.group()}"
            # Strip off the suffix from the prefix
            expandPrefix = expandName.rsplit(expandSuffix, 1)[0]

@ -792,12 +792,12 @@ class OutputGenerator:

                protect = elem.get('protect')
                if protect is not None:
-                    decl += '#ifdef {}\n'.format(protect)
+                    decl += f'#ifdef {protect}\n'


                decl += self.genRequirements(name, mustBeFound = False, indent = 2)
                decl += self.deprecationComment(elem, indent = 2)
-                decl += '    {} = {},'.format(name, strVal)
+                decl += f'    {name} = {strVal},'

                if protect is not None:
                    decl += '\n#endif'
@ -868,8 +868,8 @@ class OutputGenerator:
            if typeStr != "float":
                number += 'U'
            strVal = "~" if invert else ""
-            strVal += "static_cast<" + typeStr + ">(" + number + ")"
-            body = 'static constexpr ' + typeStr.ljust(9) + name.ljust(33) + ' {' + strVal + '};'
+            strVal += f"static_cast<{typeStr}>({number})"
+            body = f"static constexpr {typeStr.ljust(9)}{name.ljust(33)} {{{strVal}}};"
        elif enuminfo.elem.get('type') and not alias:
            # Generate e.g.: #define x (~0ULL)
            typeStr = enuminfo.elem.get('type');
@ -884,10 +884,10 @@ class OutputGenerator:
            strVal = "~" if invert else ""
            strVal += number
            if paren:
-                strVal = "(" + strVal + ")";
-            body = '#define ' + name.ljust(33) + ' ' + strVal;
+                strVal = f"({strVal})";
+            body = f"#define {name.ljust(33)} {strVal}";
        else:
-            body = '#define ' + name.ljust(33) + ' ' + strVal
+            body = f"#define {name.ljust(33)} {strVal}"

        return body

@ -1102,7 +1102,7 @@ class OutputGenerator:
        """Make the function-pointer typedef name for a command."""
        if self.genOpts is None:
            raise MissingGeneratorOptionsError()
-        return '(' + self.genOpts.apientryp + 'PFN_' + name + tail + ')'
+        return f"({self.genOpts.apientryp}PFN_{name}{tail})"

    def makeCParamDecl(self, param, aligncol):
        """Return a string which is an indented, formatted
@ -1135,14 +1135,14 @@ class OutputGenerator:
                # This works around a problem where very long type names -
                # longer than the alignment column - would run into the tail
                # text.
-                paramdecl = paramdecl.ljust(aligncol - 1) + ' '
+                paramdecl = f"{paramdecl.ljust(aligncol - 1)} "
                newLen = len(paramdecl)
                self.logMsg('diag', 'Adjust length of parameter decl from', oldLen, 'to', newLen, ':', paramdecl)

            if (self.misracppstyle() and prefix.find('const ') != -1):
                # Change pointer type order from e.g. "const void *" to "void const *".
                # If the string starts with 'const', reorder it to be after the first type.
-                paramdecl += prefix.replace('const ', '') + text + ' const' + tail
+                paramdecl += f"{prefix.replace('const ', '') + text} const{tail}"
            else:
                paramdecl += prefix + text + tail

@ -1169,7 +1169,7 @@ class OutputGenerator:

        # Allow for missing <name> tag
        newLen = 0
-        paramdecl = '    ' + noneStr(param.text)
+        paramdecl = f"    {noneStr(param.text)}"
        for elem in param:
            text = noneStr(elem.text)
            tail = noneStr(elem.tail)
@ -1400,7 +1400,7 @@ class OutputGenerator:
                            # Change pointer type order from e.g. "const void *" to "void const *".
                            # If the string starts with 'const', reorder it to be after the first type.
                            if (prefix.find('const ') != -1):
-                                param += prefix.replace('const ', '') + t + ' const '
+                                param += f"{prefix.replace('const ', '') + t} const "
                            else:
                                param += prefix + t
                            # Clear prefix for subsequent iterations
--- a/registry/parse_dependency.py
+++ b/registry/parse_dependency.py
@ -111,7 +111,7 @@ def push_first(toks):
    exprStack.append(toks[0])

 # An identifier (version, feature boolean, or extension name)
-dependencyIdent = Word(alphanums + '_' + ':')
+dependencyIdent = Word(f"{alphanums}_:")

 # Infix expression for depends expressions
 dependencyExpr = pp.infixNotation(dependencyIdent,
@ -288,7 +288,7 @@ def markupTraverse(expr, level = 0, root = True):
       - root - True only on initial call"""

    if level > 0:
-        prefix = '{nbsp}{nbsp}' * level * 2 + ' '
+        prefix = f"{'{nbsp}{nbsp}' * level * 2} "
    else:
        prefix = ''
    str = ''
@ -303,9 +303,9 @@ def markupTraverse(expr, level = 0, root = True):

            str = str + markupTraverse(elem, level = nextlevel, root = False)
        elif elem in ('+', ','):
-            str = str + f'{prefix}{opMarkupAsciidoc(elem)} +\n'
+            str = f"{str}{prefix}{opMarkupAsciidoc(elem)} +\n"
        else:
-            str = str + f'{prefix}{leafMarkupAsciidoc(elem)} +\n'
+            str = f"{str}{prefix}{leafMarkupAsciidoc(elem)} +\n"

    return str

--- a/registry/reg.py
+++ b/registry/reg.py
@ -801,7 +801,7 @@ class Registry:
                            if enum.get('alias'):
                                format_name = enum.get('alias')
                            if format_name in format_condition:
-                                format_condition[format_name] += "," + featureInfo.name
+                                format_condition[format_name] += f",{featureInfo.name}"
                            else:
                                format_condition[format_name] = featureInfo.name
                        elif groupName == "VkPipelineStageFlagBits2":
@ -810,7 +810,7 @@ class Registry:
                                stage_flag = enum.get('alias')
                            featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name
                            if stage_flag in sync_pipeline_stage_condition:
-                                sync_pipeline_stage_condition[stage_flag] += "," + featureName
+                                sync_pipeline_stage_condition[stage_flag] += f",{featureName}"
                            else:
                                sync_pipeline_stage_condition[stage_flag] = featureName
                        elif groupName == "VkAccessFlagBits2":
@ -819,7 +819,7 @@ class Registry:
                                access_flag = enum.get('alias')
                            featureName = elem.get('depends') if elem.get('depends') is not None else featureInfo.name
                            if access_flag in sync_access_condition:
-                                sync_access_condition[access_flag] += "," + featureName
+                                sync_access_condition[access_flag] += f",{featureName}"
                            else:
                                sync_access_condition[access_flag] = featureName

@ -991,7 +991,7 @@ class Registry:
                    # Look up the Info with matching groupName
                    if groupName in self.groupdict:
                        gi = self.groupdict[groupName]
-                        gienum = gi.elem.find("enum[@name='" + enumname + "']")
+                        gienum = gi.elem.find(f"enum[@name='{enumname}']")
                        if gienum is not None:
                            # Remove copy of this enum from the group
                            gi.elem.remove(gienum)
@ -1207,7 +1207,7 @@ class Registry:
                                self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = []
                            self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename)
                        else:
-                            self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
+                            self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')


                for enumElem in require.findall('enum'):
@ -1224,7 +1224,7 @@ class Registry:
                            self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = []
                        self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname)
                    else:
-                        self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
+                        self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')

                for cmdElem in require.findall('command'):
                    # Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
@ -1234,7 +1234,7 @@ class Registry:
                            self.gen.featureDictionary[featurename]['command'][required_key] = []
                        self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name'))
                    else:
-                        self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
+                        self.gen.logMsg('warn', f'fillFeatureDictionary: NOT filling for {typename}')

    def requireFeatures(self, interface, featurename, api, profile):
        """Process `<require>` tags for a `<version>` or `<extension>`.
--- a/registry/spec_tools/conventions.py
+++ b/registry/spec_tools/conventions.py
@ -52,7 +52,7 @@ class ProseListFormats(Enum):
            return cls.OR
        if s == 'and':
            return cls.AND
-        raise RuntimeError("Unrecognized string connective: " + s)
+        raise RuntimeError(f"Unrecognized string connective: {s}")

    @property
    def connective(self):
@ -96,11 +96,11 @@ class ConventionsBase(abc.ABC):

    def formatVersion(self, name, apivariant, major, minor):
        """Mark up an API version name as a link in the spec."""
-        return '`<<{}>>`'.format(name)
+        return f'`<<{name}>>`'

    def formatExtension(self, name):
        """Mark up an extension name as a link in the spec."""
-        return '`<<{}>>`'.format(name)
+        return f'`<<{name}>>`'

    def formatSPIRVlink(self, name):
        """Mark up a SPIR-V extension name as an external link in the spec.
@ -224,7 +224,7 @@ class ConventionsBase(abc.ABC):

        my_elts = list(elements)
        if len(my_elts) > 1:
-            my_elts[-1] = '{} {}'.format(fmt.connective, my_elts[-1])
+            my_elts[-1] = f'{fmt.connective} {my_elts[-1]}'

        if not comma_for_two_elts and len(my_elts) <= 2:
            prose = ' '.join(my_elts)
@ -351,7 +351,7 @@ class ConventionsBase(abc.ABC):
        Implemented in terms of api_prefix.

        May override."""
-        return self.api_prefix + 'VERSION_'
+        return f"{self.api_prefix}VERSION_"

    @property
    def KHR_prefix(self):
@ -360,7 +360,7 @@ class ConventionsBase(abc.ABC):
        Implemented in terms of api_prefix.

        May override."""
-        return self.api_prefix + 'KHR_'
+        return f"{self.api_prefix}KHR_"

    @property
    def EXT_prefix(self):
@ -369,7 +369,7 @@ class ConventionsBase(abc.ABC):
        Implemented in terms of api_prefix.

        May override."""
-        return self.api_prefix + 'EXT_'
+        return f"{self.api_prefix}EXT_"

    def writeFeature(self, featureName, featureExtraProtect, filename):
        """Return True if OutputGenerator.endFeature should write this feature.
@ -483,8 +483,7 @@ class ConventionsBase(abc.ABC):
           file.
            - name - extension name"""

-        return 'include::{{appendices}}/{}[]'.format(
-                self.extension_file_path(name))
+        return f'include::{{appendices}}/{self.extension_file_path(name)}[]'

    @property
    def provisional_extension_warning(self):
--- a/registry/validusage.json
+++ b/registry/validusage.json
--- a/registry/vk.xml
+++ b/registry/vk.xml
--- a/registry/vkconventions.py
+++ b/registry/vkconventions.py
@ -28,6 +28,7 @@ SPECIAL_WORDS = set((
    'ASTC',  # VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
    'D3D12',  # VkD3D12FenceSubmitInfoKHR
    'Float16',  # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
+    'Bfloat16',  # VkPhysicalDeviceShaderBfloat16FeaturesKHR
    'ImagePipe',  # VkImagePipeSurfaceCreateInfoFUCHSIA
    'Int64',  # VkPhysicalDeviceShaderAtomicInt64FeaturesKHR
    'Int8',  # VkPhysicalDeviceShaderFloat16Int8FeaturesKHR
@ -38,7 +39,7 @@ SPECIAL_WORDS = set((
 ))
 # A regex to match any of the SPECIAL_WORDS
 EXCEPTION_PATTERN = r'(?P<exception>{})'.format(
-    '|'.join('(%s)' % re.escape(w) for w in SPECIAL_WORDS))
+    '|'.join(f'({re.escape(w)})' for w in SPECIAL_WORDS))
 MAIN_RE = re.compile(
    # the negative lookahead is to prevent the all-caps pattern from being too greedy.
    r'({}|([0-9]+)|([A-Z][a-z]+)|([A-Z][A-Z]*(?![a-z])))'.format(EXCEPTION_PATTERN))
--- a/registry/vulkan_object.py
+++ b/registry/vulkan_object.py
@ -243,9 +243,12 @@ class Struct:
 class EnumField:
    """<enum> of type enum"""
    name: str # ex) VK_DYNAMIC_STATE_SCISSOR
-    negative: bool # True if negative values are allowed (ex. VkResult)
    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS

+    negative: bool # True if negative values are allowed (ex. VkResult)
+    value: int
+    valueStr: str # value as shown in spec (ex. "0", "2", "1000267000", "0x00000004")
+
    # some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
    extensions: list[Extension] # None if part of 1.0 core

@ -260,7 +263,7 @@ class Enum:

    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS

-    bitWidth: int # 32 or 64
+    bitWidth: int # 32 or 64 (currently all are 32, but field is to match with Bitmask)
    returnedOnly: bool

    fields: list[EnumField]
@ -279,6 +282,7 @@ class Flag:
    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS

    value: int
+    valueStr: str # value as shown in spec (ex. 0x00000000", "0x00000004", "0x0000000F", "0x800000000ULL")
    multiBit: bool # if true, more than one bit is set (ex) VK_SHADER_STAGE_ALL_GRAPHICS)
    zero: bool     # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE)

--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@ -12,7 +12,7 @@ add_test(NAME integration.add_subdirectory
        --build-and-test ${CMAKE_CURRENT_LIST_DIR}/integration
                         ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory
        --build-generator ${CMAKE_GENERATOR}
-        --build-options -DFIND_PACKAGE_TESTING=OFF -DVULKAN_HEADERS_ENABLE_MODULE=OFF
+        --build-options -DFIND_PACKAGE_TESTING=OFF -DVULKAN_HEADERS_ENABLE_MODULE=${VULKAN_HEADERS_ENABLE_MODULE}
 )

 set(test_install_dir "${CMAKE_CURRENT_BINARY_DIR}/install")
--- a/tests/integration/CMakeLists.txt
+++ b/tests/integration/CMakeLists.txt
@ -7,7 +7,7 @@
 # ~~~
 cmake_minimum_required(VERSION 3.22.1)

-project(API LANGUAGES C)
+project(API LANGUAGES C CXX)

 if (FIND_PACKAGE_TESTING)
    find_package(VulkanHeaders REQUIRED CONFIG)
@ -18,6 +18,9 @@ endif()
 if (NOT TARGET Vulkan::Headers)
    message(FATAL_ERROR "Vulkan::Headers target not defined")
 endif()
+if (NOT TARGET Vulkan::HppModule AND VULKAN_HEADERS_ENABLE_MODULE)
+    message(FATAL_ERROR "Vulkan::HppModule target not defined")
+endif()

 if (FIND_PACKAGE_TESTING)
    if (NOT DEFINED VulkanHeaders_VERSION)
@ -37,6 +40,9 @@ if (NOT FIND_PACKAGE_TESTING)
    if (NOT TARGET Vulkan-Headers)
        message(FATAL_ERROR "Backcompat for Vulkan-Headers target broken!")
    endif()
+    if (NOT TARGET Vulkan-HppModule AND VULKAN_HEADERS_ENABLE_MODULE)
+        message(FATAL_ERROR "Backcompat for Vulkan-HppModule target broken!")
+    endif()
 endif()

 set(CMAKE_C_STANDARD 99)
@ -71,3 +77,15 @@ target_link_libraries(vk_icd PRIVATE Vulkan::Headers)
 # vk_layer.h
 add_library(vk_layer MODULE ../vk_layer.c)
 target_link_libraries(vk_layer PRIVATE Vulkan::Headers)
+
+# vulkan.hpp
+add_library(vk_hpp MODULE ../vk_hpp.cpp)
+target_compile_features(vk_hpp PUBLIC cxx_std_11)
+target_link_libraries(vk_hpp PRIVATE Vulkan::Headers)
+
+# vulkan.cppm
+if (VULKAN_HEADERS_ENABLE_MODULE)
+    add_library(vk_hpp_module MODULE ../vk_hpp_module.cpp)
+    set_target_properties(vk_hpp_module PROPERTIES CXX_SCAN_FOR_MODULES ON)
+    target_link_libraries(vk_hpp_module PRIVATE Vulkan::HppModule)
+endif()
--- a/tests/vk_hpp.cpp
+++ b/tests/vk_hpp.cpp
@ -0,0 +1,13 @@
+/*
+ * Copyright 2025 The Khronos Group Inc.
+ * Copyright 2025 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <vulkan/vulkan.hpp>
+
+int header_version()
+{
+    return VK_HEADER_VERSION;
+}
--- a/tests/vk_hpp_module.cpp
+++ b/tests/vk_hpp_module.cpp
@ -0,0 +1,13 @@
+/*
+ * Copyright 2025 The Khronos Group Inc.
+ * Copyright 2025 Valve Corporation
+ * Copyright 2025 LunarG, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import vulkan_hpp;
+
+int test_version()
+{
+    return static_cast<int>(vk::makeApiVersion(1, 0, 0, 0));
+}
Author	SHA1	Message	Date
Jon Leech	5ceb9ed481	Update for Vulkan-Docs 1.4.312 Some checks failed ci / cmake-unix (3.22.1, ubuntu-latest) (push) Failing after 1s Details ci / cmake-unix (latest, ubuntu-latest) (push) Failing after 1s Details ci / cmake-unix-modules (latest, clang++-18, ubuntu-latest) (push) Failing after 1s Details ci / reuse (push) Failing after 1s Details ci / cmake-unix (3.22.1, macos-latest) (push) Has been cancelled Details ci / cmake-unix (latest, macos-latest) (push) Has been cancelled Details ci / cmake-windows (3.22.1) (push) Has been cancelled Details ci / cmake-windows (latest) (push) Has been cancelled Details ci / windows_clang (clang) (push) Has been cancelled Details ci / windows_clang (clang-cl) (push) Has been cancelled Details ci / cmake-windows-modules (latest, windows-latest) (push) Has been cancelled Details	2025-04-04 04:45:22 -07:00
Jan Kuhlmann	2ac81691ba	adjusted fnc name Some checks failed ci / windows_clang (clang-cl) (push) Has been cancelled Details ci / cmake-unix (3.22.1, ubuntu-latest) (push) Failing after 2s Details ci / cmake-unix (latest, ubuntu-latest) (push) Failing after 2s Details ci / cmake-unix-modules (latest, clang++-18, ubuntu-latest) (push) Failing after 1s Details ci / reuse (push) Failing after 1s Details ci / cmake-unix (latest, macos-latest) (push) Has been cancelled Details ci / cmake-windows (3.22.1) (push) Has been cancelled Details ci / cmake-windows-modules (latest, windows-latest) (push) Has been cancelled Details ci / cmake-windows (latest) (push) Has been cancelled Details ci / cmake-unix (3.22.1, macos-latest) (push) Has been cancelled Details ci / windows_clang (clang) (push) Has been cancelled Details	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	a523083f72	simplified cpp module to not require function loading	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	cb28cd1819	replaced minimal example for modules	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	24ce771ec1	fixed linewrap on windows and CXX compiler on ubuntu	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	cafcda9360	Added licenses and used included headers in minimal examples Co-authored-by: jpr42 <109434725+jpr42@users.noreply.github.com>	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	2b1e9e7409	added c++20 workflows for modules in ubuntu and windows	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	a72b4466b3	minimal compilation setups for Vulkan::Hpp and Vulkan::HppModule	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	fdc7404466	merged subdirectory tests	2025-03-31 09:52:53 -06:00
Jan Kuhlmann	9417d66dcf	integration tests for cxx modules	2025-03-31 09:52:53 -06:00
Jon Leech	78c359741d	Update for Vulkan-Docs 1.4.311	2025-03-20 23:33:08 -07:00
Jan Kuhlmann	d64e9e156a	cmake: Rename Vulkan-Module to Vulkan-HppModule The new name better indicates that the target is for Vulkan-Hpp. The old Vulkan-Module and Vulkan::Module targets are now deprecated and users should switch to Vulkan-HppModule. Vulkan-HppModule now supports `import std` when available. The commit disables cxx_extensions when using clang-16 due to known issues.	2025-03-17 15:44:30 -06:00