Merge branch 'main' into ctest-testing

Co-authored-by: GitHub <noreply@github.com>

.github/workflows/ci-ubuntu-ext.yml

@@ -15,7 +15,7 @@ jobs:
 
     strategy:
       matrix:
-        clang_version: [19, 20, 21]
+        clang_version: [20, 21]
 
     steps:
     - uses: actions/checkout@v4
@@ -25,28 +25,28 @@ jobs:
     - name: Install libraries
       run: sudo apt update && sudo apt install libgl-dev libxcursor-dev libxi-dev libxinerama-dev libxrandr-dev
 
-    - name: Install Ninja
-      uses: ashutoshvarma/setup-ninja@master
+    - name: Install CMake and Ninja
+      uses: lukka/get-cmake@latest
       with:
-        version: 1.11.0
-    - name: Install Clang and CMake
+        cmakeVersion: 4.1.2
+        ninjaVersion: latest
+
+    - name: Install Clang
       run: |
         sudo apt-get update && sudo apt-get install lsb-release gpg software-properties-common wget
         wget https://apt.llvm.org/llvm.sh
         chmod +x llvm.sh
         sudo ./llvm.sh ${{matrix.clang_version}} all
-
-        sudo apt purge -y --auto-remove cmake
-        wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | sudo tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
-        echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ noble main' | sudo tee /etc/apt/sources.list.d/kitware.list >/dev/null
-        sudo apt update && sudo apt install cmake
+        sudo ln -s /lib/llvm-${{matrix.clang_version}}/share /lib/share
 
     - name: Install glm, glfw and glslang
       run: |
         cd glm
         cmake -B build -G Ninja                                   \
+          -D CMAKE_C_COMPILER=clang-${{matrix.clang_version}}     \
           -D CMAKE_CXX_COMPILER=clang++-${{matrix.clang_version}} \
           -D CMAKE_CXX_STANDARD=11                                \
+          -D CMAKE_CXX_FLAGS=-stdlib=libc++                       \
           -D CMAKE_BUILD_TYPE=Release                             \
           -D GLM_BUILD_LIBRARY=ON                                 \
           -D GLM_BUILD_INSTALL=ON                                 \
@@ -56,8 +56,10 @@ jobs:
 
         cd ../glfw
         cmake -B build -G Ninja                                   \
+          -D CMAKE_C_COMPILER=clang-${{matrix.clang_version}}     \
           -D CMAKE_CXX_COMPILER=clang++-${{matrix.clang_version}} \
           -D CMAKE_CXX_STANDARD=11                                \
+          -D CMAKE_CXX_FLAGS=-stdlib=libc++                       \
           -D CMAKE_BUILD_TYPE=Release                             \
           -D GLFW_BUILD_EXAMPLES=OFF                              \
           -D GLFW_BUILD_TESTS=OFF                                 \
@@ -68,8 +70,10 @@ jobs:
 
         cd ../glslang
         cmake -B build -G Ninja                                   \
+          -D CMAKE_C_COMPILER=clang-${{matrix.clang_version}}     \
           -D CMAKE_CXX_COMPILER=clang++-${{matrix.clang_version}} \
           -D CMAKE_CXX_STANDARD=11                                \
+          -D CMAKE_CXX_FLAGS=-stdlib=libc++                       \
           -D CMAKE_BUILD_TYPE=Release                             \
           -D ENABLE_OPT=OFF                                       \
           -D GLSLANG_TESTS_DEFAULT=OFF                            \
@@ -90,6 +94,7 @@ jobs:
           -D VULKAN_HPP_PRECOMPILE=OFF                              \
           -D CMAKE_CXX_COMPILER=clang++-${{matrix.clang_version}}   \
           -D CMAKE_CXX_STANDARD=20                                  \
+          -D CMAKE_CXX_FLAGS=-stdlib=libc++                         \
           -D CMAKE_BUILD_TYPE=Debug
         cmake --build build --parallel
 
@@ -103,12 +108,13 @@ jobs:
           -D VULKAN_HPP_PRECOMPILE=OFF                              \
           -D CMAKE_CXX_COMPILER=clang++-${{matrix.clang_version}}   \
           -D CMAKE_CXX_STANDARD=20                                  \
+          -D CMAKE_CXX_FLAGS=-stdlib=libc++                         \
           -D CMAKE_BUILD_TYPE=Release
         cmake --build build --parallel --clean-first
 
     - name: Build samples and tests
       run: |
-        for CXX_STANDARD in 23; do
+        for CXX_STANDARD in 11 14 17 20 23; do
           for BUILD_TYPE in Debug Release; do
 
             CXX_MODULES=ON
@@ -132,7 +138,9 @@ jobs:
               -D VULKAN_HPP_PRECOMPILE=OFF                            \
               -D CMAKE_CXX_COMPILER=clang++-${{matrix.clang_version}} \
               -D CMAKE_CXX_STANDARD=$CXX_STANDARD                     \
-              -D CMAKE_BUILD_TYPE=$BUILD_TYPE
+              -D CMAKE_CXX_FLAGS=-stdlib=libc++                       \
+              -D CMAKE_BUILD_TYPE=$BUILD_TYPE                         \
+              -D CMAKE_EXPERIMENTAL_CXX_IMPORT_STD=d0edc3af-4c50-42ea-a356-e2862fe7a444
             cmake --build build --parallel --clean-first
             ctest -j --output-on-failure --test-dir build
           done

.github/workflows/ci-windows-clang.yml

@@ -1,5 +1,5 @@
 
-name: CI Windows
+name: CI Windows Clang
 
 on:
   pull_request:
@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         os: [windows-2022, windows-2025]
-        architecture: [x86, x64]
+        architecture: [x64]
 
     steps:
     - uses: actions/checkout@v4
@@ -31,8 +31,10 @@ jobs:
     # - name: Install glm, glfw and glslang
     #   run: |
     #     cd glm
-    #     cmake -B build                               \
+    #     cmake -B build -G Ninja          \
+    #       -D CMAKE_CXX_COMPILER=clang-cl \
     #       -D CMAKE_CXX_STANDARD=11       \
+    #       -D CMAKE_BUILD_TYPE=Release    \
     #       -D GLM_BUILD_LIBRARY=ON        \
     #       -D GLM_BUILD_INSTALL=ON        \
     #       -D GLM_BUILD_TESTS=OFF
@@ -40,8 +42,9 @@ jobs:
     #     cmake --install build --config Release
 
     #     cd ../glfw
-    #     cmake -B build                               \
-    #       -D CMAKE_CXX_STANDARD=11                   \
+    #     cmake -B build -G Ninja          \
+    #       -D CMAKE_C_COMPILER=clang-cl   \
+    #       -D CMAKE_BUILD_TYPE=Release    \
     #       -D GLFW_BUILD_EXAMPLES=OFF     \
     #       -D GLFW_BUILD_TESTS=OFF        \
     #       -D GLFW_BUILD_DOCS=OFF         \
@@ -50,8 +53,11 @@ jobs:
     #     cmake --install build --config Release
 
     #     cd ../glslang
-    #     cmake -B build                               \
+    #     cmake -B build -G Ninja          \
+    #       -D CMAKE_C_COMPILER=clang-cl   \
+    #       -D CMAKE_CXX_COMPILER=clang-cl \
     #       -D CMAKE_CXX_STANDARD=11       \
+    #       -D CMAKE_BUILD_TYPE=Release    \
     #       -D ENABLE_OPT=OFF              \
     #       -D GLSLANG_TESTS_DEFAULT=OFF   \
     #       -D GLSLANG_ENABLE_INSTALL_DEFAULT=ON
@@ -61,7 +67,7 @@ jobs:
 
     - name: Generate headers
       run: |
-        cmake -B build                                 \
+        cmake -B build -G Ninja                        \
           -D VULKAN_HPP_GENERATOR_BUILD=ON             \
           -D VULKAN_HPP_RUN_GENERATOR=OFF              \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
@@ -69,10 +75,12 @@ jobs:
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
+          -D CMAKE_BUILD_TYPE=Debug                    \
+          -D CMAKE_CXX_COMPILER=clang-cl               \
           -D CMAKE_CXX_STANDARD=20
-        cmake --build build --parallel --config Debug
+        cmake --build build --parallel
 
-        cmake -B build --fresh                         \
+        cmake -B build -G Ninja --fresh                \
           -D VULKAN_HPP_GENERATOR_BUILD=ON             \
           -D VULKAN_HPP_RUN_GENERATOR=ON               \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
@@ -80,8 +88,10 @@ jobs:
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
+          -D CMAKE_BUILD_TYPE=Release                  \
+          -D CMAKE_CXX_COMPILER=clang-cl               \
           -D CMAKE_CXX_STANDARD=20
-        cmake --build build --parallel --config Release
+        cmake --build build --parallel --clean-first
 
     - name: Build samples and tests
       run: |
@@ -97,7 +107,7 @@ jobs:
             echo "Building C++$CXX_STANDARD in $BUILD_TYPE with architecture ${{matrix.architecture}}"
             echo "================================================================================="
 
-            cmake -B build --fresh                   \
+            cmake -B build -G Ninja --fresh                   \
               -D VULKAN_HPP_BUILD_CXX_MODULE=$CXX_MODULES     \
               -D VULKAN_HPP_GENERATOR_BUILD=OFF               \
               -D VULKAN_HPP_RUN_GENERATOR=OFF                 \
@@ -107,8 +117,11 @@ jobs:
               -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON        \
               -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON    \
               -D VULKAN_HPP_PRECOMPILE=OFF                    \
-              -D CMAKE_CXX_STANDARD=$CXX_STANDARD
-            cmake --build build --parallel --clean-first --config $BUILD_TYPE
-            ctest -j --output-on-failure --test-dir build -C $BUILD_TYPE
+              -D CMAKE_BUILD_TYPE=$BUILD_TYPE                 \
+              -D CMAKE_C_COMPILER=clang-cl                    \
+              -D CMAKE_CXX_COMPILER=clang-cl                  \
+              -D CMAKE_CXX_STANDARD=$CXX_STANDARD             \
+              -D CMAKE_EXPERIMENTAL_CXX_IMPORT_STD=d0edc3af-4c50-42ea-a356-e2862fe7a444
+            cmake --build build --parallel --clean-first
           done
         done

.github/workflows/ci-windows-msvc.yml

@@ -0,0 +1,97 @@
+
+name: CI Windows MSVC
+
+on:
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ${{matrix.os}}
+
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      matrix:
+        os: [windows-2022, windows-2025]
+        architecture: [x86, x64]
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Setup MSVC
+      uses: TheMrMilchmann/setup-msvc-dev@v2
+      with:
+        arch: ${{matrix.architecture}}
+
+    # - name: Install glm, glfw and glslang
+    #   run: |
+    #     cd glm
+    #     cmake -B build                               \
+    #       -D CMAKE_CXX_STANDARD=11                   \
+    #       -D GLM_BUILD_LIBRARY=ON                    \
+    #       -D GLM_BUILD_INSTALL=ON                    \
+    #       -D GLM_BUILD_TESTS=OFF
+    #     cmake --build build --parallel --config Release
+    #     cmake --install build --config Release
+
+    #     cd ../glfw
+    #     cmake -B build                               \
+    #       -D CMAKE_CXX_STANDARD=11                   \
+    #       -D GLFW_BUILD_EXAMPLES=OFF                 \
+    #       -D GLFW_BUILD_TESTS=OFF                    \
+    #       -D GLFW_BUILD_DOCS=OFF                     \
+    #       -D GLFW_INSTALL=ON
+    #     cmake --build build --parallel --config Release
+    #     cmake --install build --config Release
+
+    #     cd ../glslang
+    #     cmake -B build                               \
+    #       -D CMAKE_CXX_STANDARD=11                   \
+    #       -D ENABLE_OPT=OFF                          \
+    #       -D GLSLANG_TESTS_DEFAULT=OFF               \
+    #       -D GLSLANG_ENABLE_INSTALL_DEFAULT=ON
+    #     cmake --build build --parallel --config Release
+    #     cmake --install build --config Release
+    #     cd ..
+
+    - name: Generate headers
+      run: |
+        cmake -B build                                 \
+          -D VULKAN_HPP_GENERATOR_BUILD=ON             \
+          -D VULKAN_HPP_RUN_GENERATOR=OFF              \
+          -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
+          -D VULKAN_HPP_TESTS_BUILD=OFF                \
+          -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
+          -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
+          -D VULKAN_HPP_PRECOMPILE=OFF                 \
+          -D CMAKE_CXX_STANDARD=20
+        cmake --build build --parallel --config Debug
+        cmake --build build --parallel --config Release
+
+    - name: Build samples and tests
+      run: |
+        for CXX_STANDARD in 11 14 17 20 23; do
+          echo "================================================================================="
+          echo "Building C++$CXX_STANDARD in Debug with architecture ${{matrix.architecture}}"
+          echo "================================================================================="
+          cmake -B build --fresh                            \
+            -D VULKAN_HPP_GENERATOR_BUILD=OFF               \
+            -D VULKAN_HPP_RUN_GENERATOR=OFF                 \
+            -D VULKAN_HPP_SAMPLES_BUILD=ON                  \
+            -D VULKAN_HPP_TESTS_BUILD=ON                    \
+            -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON        \
+            -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON    \
+            -D VULKAN_HPP_PRECOMPILE=OFF                    \
+            -D CMAKE_CXX_STANDARD=$CXX_STANDARD
+          cmake --build build --parallel --clean-first --config Debug
+
+          echo "================================================================================="
+          echo "Building C++$CXX_STANDARD in Release with architecture ${{matrix.architecture}}"
+          echo "================================================================================="
+          cmake --build build --parallel --config Release
+        done

CMakeLists.txt

@@ -50,6 +50,7 @@ option( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC "Change the m_mask access modifier
 option( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS "Handles VK_ERROR_OUT_OF_DATE_KHR like a success code" OFF )
 option( VULKAN_HPP_HANDLES_MOVE_EXCHANGE "Enable 'm_handle = exchange( rhs.m_handle, {} )' in move constructors" OFF )
 option( VULKAN_HPP_NO_CONSTRUCTORS "Remove constructors from structs and unions to enable C++20 designated initializers" OFF )
+option( VULKAN_HPP_NO_DEFAULT_DISPATCHER "Remove the default dispatcher argument from functions, requiring manually specifying one" OFF )
 option( VULKAN_HPP_NO_EXCEPTIONS "Do not throw exceptions when vulkan functions return an error code" OFF )
 option( VULKAN_HPP_NO_NODISCARD_WARNINGS "Remove C++17 [[nodiscard]] from function signatures that return something" OFF )
 option( VULKAN_HPP_NO_SETTERS "Remove setters for structs and unions" OFF )
@@ -309,6 +310,9 @@ function( vulkan_hpp__setup_vulkan_targets )
 	if( VULKAN_HPP_NO_CONSTRUCTORS )
 		target_compile_definitions(VulkanHpp INTERFACE "VULKAN_HPP_NO_CONSTRUCTORS" )
 	endif()
+	if( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
+		target_compile_definitions(VulkanHpp INTERFACE "VULKAN_HPP_NO_DEFAULT_DISPATCHER" )
+	endif()
 	if( VULKAN_HPP_NO_SMART_HANDLE )
 		target_compile_definitions(VulkanHpp INTERFACE "VULKAN_HPP_NO_SMART_HANDLE" )
 	endif()

RAII_Samples/DebugUtilsObjectName/DebugUtilsObjectName.cpp

@@ -47,8 +47,7 @@ int main( int /*argc*/, char ** /*argv*/ )
 
     /* VULKAN_KEY_START */
 
-    vk::DebugUtilsObjectNameInfoEXT debugUtilsObjectNameInfo( vk::ObjectType::eImage, NON_DISPATCHABLE_HANDLE_TO_UINT64_CAST( VkImage, *image ), "Image name" );
-    device.setDebugUtilsObjectNameEXT( debugUtilsObjectNameInfo );
+    device.setDebugUtilsObjectNameEXT( *image, "Image name" );
 
     /* VULKAN_KEY_END */
   }

RAII_Samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 // no need to ignore any warnings with MSVC
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"

RAII_Samples/InitTexture/InitTexture.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 // no need to ignore any warnings with MSVC
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"

RAII_Samples/PipelineCache/PipelineCache.cpp

@@ -142,8 +142,7 @@ int main( int /*argc*/, char ** /*argv*/ )
     /* VULKAN_KEY_START */
 
     // Check disk for existing cache data
-    size_t startCacheSize = 0;
-    char * startCacheData = nullptr;
+    std::vector<char> startCacheData;
 
     std::string   cacheFileName = "pipeline_cache_data.bin";
     std::ifstream readCacheStream( cacheFileName, std::ios_base::in | std::ios_base::binary );
@@ -151,14 +150,14 @@ int main( int /*argc*/, char ** /*argv*/ )
     {
       // Determine cache size
       readCacheStream.seekg( 0, readCacheStream.end );
-      startCacheSize = static_cast<size_t>( readCacheStream.tellg() );
+      size_t startCacheSize = static_cast<size_t>( readCacheStream.tellg() );
       readCacheStream.seekg( 0, readCacheStream.beg );
 
       // Allocate memory to hold the initial cache data
-      startCacheData = (char *)std::malloc( startCacheSize );
+      startCacheData.resize( startCacheSize );
 
       // Read the data into our buffer
-      readCacheStream.read( startCacheData, startCacheSize );
+      readCacheStream.read( startCacheData.data(), startCacheData.size() );
 
       // Clean up and print results
       readCacheStream.close();
@@ -171,7 +170,7 @@ int main( int /*argc*/, char ** /*argv*/ )
       std::cout << "  Pipeline cache miss!\n";
     }
 
-    if ( startCacheData != nullptr )
+    if ( !startCacheData.empty() )
     {
       // Check for cache validity
       //
@@ -207,11 +206,12 @@ int main( int /*argc*/, char ** /*argv*/ )
       uint32_t deviceID                        = 0;
       uint8_t  pipelineCacheUUID[VK_UUID_SIZE] = {};
 
-      memcpy( &headerLength, (uint8_t *)startCacheData + 0, 4 );
-      memcpy( &cacheHeaderVersion, (uint8_t *)startCacheData + 4, 4 );
-      memcpy( &vendorID, (uint8_t *)startCacheData + 8, 4 );
-      memcpy( &deviceID, (uint8_t *)startCacheData + 12, 4 );
-      memcpy( pipelineCacheUUID, (uint8_t *)startCacheData + 16, VK_UUID_SIZE );
+      uint8_t * startCacheDataPtr = reinterpret_cast<uint8_t *>( startCacheData.data() );
+      memcpy( &headerLength, startCacheDataPtr + 0, 4 );
+      memcpy( &cacheHeaderVersion, startCacheDataPtr + 4, 4 );
+      memcpy( &vendorID, startCacheDataPtr + 8, 4 );
+      memcpy( &deviceID, startCacheDataPtr + 12, 4 );
+      memcpy( pipelineCacheUUID, startCacheDataPtr + 16, VK_UUID_SIZE );
 
       // Check each field and report bad values before freeing existing cache
       bool badCache = false;
@@ -257,9 +257,7 @@ int main( int /*argc*/, char ** /*argv*/ )
       if ( badCache )
       {
         // Don't submit initial cache data if any version info is incorrect
-        free( startCacheData );
-        startCacheSize = 0;
-        startCacheData = nullptr;
+        startCacheData.clear();
 
         // And clear out the old cache file for use in next run
         std::cout << "  Deleting cache entry " << cacheFileName << " to repopulate.\n";
@@ -272,12 +270,11 @@ int main( int /*argc*/, char ** /*argv*/ )
     }
 
     // Feed the initial cache data into cache creation
-    vk::PipelineCacheCreateInfo pipelineCacheCreateInfo( {}, startCacheSize, startCacheData );
+    vk::PipelineCacheCreateInfo pipelineCacheCreateInfo( {}, startCacheData.size(), startCacheData.data() );
     vk::raii::PipelineCache     pipelineCache( device, pipelineCacheCreateInfo );
 
     // Free our initialData now that pipeline cache has been created
-    free( startCacheData );
-    startCacheData = NULL;
+    startCacheData.clear();
 
     // Time (roughly) taken to create the graphics pipeline
     timestamp_t        start            = getMilliseconds();

Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 33d7f512583b8de44d1b6384aa1cf482f92e53e9
+Subproject commit 6aefb8eb95c8e170d0805fd0f2d02832ec1e099a

VulkanHppGenerator.hpp

@@ -248,6 +248,13 @@ private:
     std::map<std::string, DefineData> values  = {};
   };
 
+  struct EnumConstantData
+  {
+    std::string name    = {};
+    std::string value   = {};
+    int         xmlLine = {};
+  };
+
   struct RequireFeature
   {
     std::vector<std::string> name      = {};
@@ -269,8 +276,8 @@ private:
     std::string                   api           = {};
     std::string                   depends       = {};
     std::vector<NameLine>         commands      = {};
-    std::map<std::string, std::string> enumConstants = {};
-    std::vector<std::string>           constants     = {};
+    std::vector<EnumConstantData> enumConstants = {};
+    std::vector<NameLine>         constants     = {};
     std::vector<RequireFeature>   features      = {};
     std::vector<NameLine>         types         = {};
     int                           xmlLine       = {};
@@ -420,7 +427,7 @@ private:
     int                                               xmlLine = {};
   };
 
-  struct StructureData
+  struct StructData
   {
     std::map<std::string, int> aliases             = {};
     bool                       allowDuplicate      = {};
@@ -569,7 +576,7 @@ private:
   bool containsFloatingPoints( std::vector<MemberData> const & members ) const;
   bool containsName( std::vector<EnumValueData> const & enumValues, std::string const & name ) const;
   bool containsUnion( std::string const & type ) const;
-  bool describesVector( StructureData const & structure, std::string const & type = "" ) const;
+  bool describesVector( StructData const & structure, std::string const & type = "" ) const;
   std::vector<size_t>      determineChainedReturnParams( std::vector<ParamData> const & params, std::vector<size_t> const & returnParams ) const;
   std::vector<size_t>      determineConstPointerParams( std::vector<ParamData> const & params ) const;
   std::vector<std::string> determineDataTypes( std::vector<VulkanHppGenerator::ParamData> const & params,
@@ -590,19 +597,33 @@ private:
                                                               std::map<size_t, VectorParamData> const & vectorParams,
                                                               std::vector<size_t> const &               returnParam,
                                                               bool                                      singular ) const;
-  std::string                                determineSubStruct( std::pair<std::string, StructureData> const & structure ) const;
+  std::string                         determineSubStruct( std::pair<std::string, StructData> const & structure ) const;
   std::map<size_t, VectorParamData>   determineVectorParams( std::vector<ParamData> const & params ) const;
   std::set<size_t>                    determineVoidPointerParams( std::vector<ParamData> const & params ) const;
-  void                                       distributeEnumExtends();
   void                                distributeEnumValueAliases();
   void                                distributeRequirements();
   void                                distributeRequirements( std::vector<RequireData> const & requireData, std::string const & requiredBy );
   void                                distributeStructAliases();
+  void                                extendSpecialCommands( std::string const & name, bool definition, bool raii, std::string & cmd ) const;
   void                                filterLenMembers();
-  std::vector<ExtensionData>::const_iterator findSupportedExtension( std::string const & name ) const;
   std::string                         findTag( std::string const & name, std::string const & postfix = "" ) const;
+  void                                forEachRequiredBitmask( std::vector<RequireData> const &                                           requireData,
+                                                              std::set<std::string> &                                                    encounteredBitmasks,
+                                                              std::function<void( std::pair<std::string, BitmaskData> const & )> const & bitmaskAction ) const;
   void                                forEachRequiredCommand( std::vector<RequireData> const &                                                             requireData,
                                                               std::function<void( NameLine const &, std::pair<std::string, CommandData> const & )> const & commandAction ) const;
+  void                                forEachRequiredConstant( std::vector<RequireData> const &                                            requireData,
+                                                               std::set<std::string> &                                                     encounteredConstants,
+                                                               std::function<void( std::pair<std::string, ConstantData> const & )> const & constantAction ) const;
+  void                                forEachRequiredEnumConstant( std::vector<RequireData> const &                        requireData,
+                                                                   std::set<std::string> &                                 encounteredEnumConstants,
+                                                                   std::function<void( EnumConstantData const & )> const & enumConstantAction ) const;
+  void                                forEachRequiredFuncPointer( std::vector<RequireData> const &                                               requireData,
+                                                                  std::function<void( std::pair<std::string, FuncPointerData> const & )> const & funcPointerAction ) const;
+  void                                forEachRequiredHandle( std::vector<RequireData> const &                                          requireData,
+                                                             std::function<void( std::pair<std::string, HandleData> const & )> const & handleAction ) const;
+  void                                forEachRequiredStruct( std::vector<RequireData> const &                                          requireData,
+                                                             std::function<void( std::pair<std::string, StructData> const & )> const & structAction ) const;
   std::set<std::string>               gatherResultCodes() const;
   std::pair<std::string, std::string> generateAllocatorTemplates( std::vector<size_t> const &               returnParams,
                                                                   std::vector<std::string> const &          returnDataTypes,
@@ -633,7 +654,7 @@ private:
   std::string generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt, std::string const & surroundingProtect ) const;
   std::string generateBitmasksToString() const;
   std::string generateBitmasksToString( std::vector<RequireData> const & requireData, std::set<std::string> & listedBitmasks, std::string const & title ) const;
-  std::string generateBitmaskToString( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const;
+  std::string generateBitmaskToString( std::pair<std::string, BitmaskData> const & bitmaskData ) const;
   std::string generateCallArgumentsEnhanced( CommandData const &      commandData,
                                              size_t                   initialSkipCount,
                                              bool                     nonConstPointerAsNullptr,
@@ -771,7 +792,7 @@ private:
                                           bool                        definition,
                                           std::vector<size_t> const & returnParamIndices,
                                           bool                        raii ) const;
-  std::string generateConstexprString( std::pair<std::string, StructureData> const & structData ) const;
+  std::string generateConstexprString( std::pair<std::string, StructData> const & structData ) const;
   std::string generateConstexprDefines() const;
   std::string generateConstexprUsings() const;
   std::string generateCppModuleFuncpointerUsings() const;
@@ -1063,26 +1084,26 @@ private:
     generateSizeCheck( std::vector<std::vector<MemberData>::const_iterator> const & arrayIts, std::string const & structName, bool mutualExclusiveLens ) const;
   std::string generateStaticAssertions() const;
   std::string generateStaticAssertions( std::vector<RequireData> const & requireData, std::string const & title, std::set<std::string> & listedStructs ) const;
-  std::string generateStruct( std::pair<std::string, StructureData> const & structure, std::set<std::string> & listedStructs ) const;
-  std::string generateStructCastAssignments( std::pair<std::string, StructureData> const & structData ) const;
-  std::string generateStructCompareOperators( std::pair<std::string, StructureData> const & structure ) const;
-  std::string generateStructConstructors( std::pair<std::string, StructureData> const & structData ) const;
-  std::string generateStructConstructorsEnhanced( std::pair<std::string, StructureData> const & structData ) const;
+  std::string generateStruct( std::pair<std::string, StructData> const & structure, std::set<std::string> & listedStructs ) const;
+  std::string generateStructCastAssignments( std::pair<std::string, StructData> const & structData ) const;
+  std::string generateStructCompareOperators( std::pair<std::string, StructData> const & structure ) const;
+  std::string generateStructConstructors( std::pair<std::string, StructData> const & structData ) const;
+  std::string generateStructConstructorsEnhanced( std::pair<std::string, StructData> const & structData ) const;
   std::string generateStructConstructorArgument( MemberData const & memberData, bool withDefault ) const;
-  std::string generateStructHashStructure( std::pair<std::string, StructureData> const & structure, std::set<std::string> & listedStructs ) const;
+  std::string generateStructHashStructure( std::pair<std::string, StructData> const & structure, std::set<std::string> & listedStructs ) const;
   std::string generateStructHashStructures() const;
   std::string generateStructHashSum( std::string const & structName, std::vector<MemberData> const & members ) const;
   std::string generateStructs() const;
-  std::string generateStructure( std::pair<std::string, StructureData> const & structure ) const;
+  std::string generateStructure( std::pair<std::string, StructData> const & structure ) const;
   std::string generateStructExtendsStructs() const;
   std::string
     generateStructExtendsStructs( std::vector<RequireData> const & requireData, std::set<std::string> & listedStructs, std::string const & title ) const;
   std::string generateStructForwardDeclarations() const;
   std::string
     generateStructForwardDeclarations( std::vector<RequireData> const & requireData, std::string const & title, std::set<std::string> & listedStructs ) const;
-  std::tuple<std::string, std::string, std::string, std::string> generateStructMembers( std::pair<std::string, StructureData> const & structData ) const;
+  std::tuple<std::string, std::string, std::string, std::string> generateStructMembers( std::pair<std::string, StructData> const & structData ) const;
   std::string generateStructSetter( std::string const & structureName, std::vector<MemberData> const & memberData, size_t index ) const;
-  std::string generateStructSubConstructor( std::pair<std::string, StructureData> const & structData ) const;
+  std::string generateStructSubConstructor( std::pair<std::string, StructData> const & structData ) const;
   std::string generateSuccessCheck( std::vector<std::string> const & successCodes ) const;
   std::string generateSuccessCode( std::string const & code ) const;
   std::string generateSuccessCodeList( std::vector<std::string> const & successCodes, bool enumerating ) const;
@@ -1093,7 +1114,7 @@ private:
                                      bool                                      definition,
                                      std::vector<std::string> const &          dataTypes,
                                      CommandFlavourFlags                       flavourFlags ) const;
-  std::string generateUnion( std::pair<std::string, StructureData> const & structure ) const;
+  std::string generateUnion( std::pair<std::string, StructData> const & structure ) const;
   std::string generateUniqueHandle( std::pair<std::string, HandleData> const & handleData ) const;
   std::string generateUniqueHandle( std::vector<RequireData> const & requireData, std::string const & title, std::set<std::string> & listedHandles ) const;
   std::string generateUniqueHandles() const;
@@ -1252,7 +1273,6 @@ private:
   std::map<std::string, ConstantData>           m_constants;
   std::map<std::string, DefineData>             m_defines;
   DefinesPartition                              m_definesPartition;  // partition defined macros into mutually-exclusive sets of callees, callers, and values
-  std::map<std::string, std::vector<EnumExtendData>> m_enumExtends;
   std::map<std::string, EnumData>               m_enums;
   std::vector<ExtensionData>                    m_extensions;
   std::map<std::string, ExternalTypeData>       m_externalTypes;
@@ -1264,7 +1284,7 @@ private:
   std::map<std::string, PlatformData>           m_platforms;
   std::set<std::string>                         m_RAIISpecialFunctions;
   std::map<std::string, SpirVCapabilityData>    m_spirVCapabilities;
-  std::map<std::string, StructureData>               m_structs;
+  std::map<std::string, StructData>             m_structs;
   std::vector<std::pair<std::string, NameLine>> m_structsAliases;  // temporary storage for aliases, as they might be listed before the actual struct is listed
   std::map<std::string, NameLine>               m_syncAccesses;
   std::map<std::string, NameLine>               m_syncStages;

samples/02_EnumerateDevices/02_EnumerateDevices.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 // no need to ignore any warnings with MSVC
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"

samples/DebugUtilsObjectName/DebugUtilsObjectName.cpp

@@ -55,8 +55,7 @@ int main( int /*argc*/, char ** /*argv*/ )
 
     /* VULKAN_KEY_START */
 
-    vk::DebugUtilsObjectNameInfoEXT debugUtilsObjectNameInfo( vk::ObjectType::eImage, NON_DISPATCHABLE_HANDLE_TO_UINT64_CAST( VkImage, image ), "Image name" );
-    device.setDebugUtilsObjectNameEXT( debugUtilsObjectNameInfo );
+    device.setDebugUtilsObjectNameEXT( image, "Image name" );
 
     /* VULKAN_KEY_END */
 

samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 // no need to ignore any warnings with MSVC
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"

samples/InitTexture/InitTexture.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 // no need to ignore any warnings with MSVC
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"

samples/PipelineCache/PipelineCache.cpp

@@ -140,8 +140,7 @@ int main( int /*argc*/, char ** /*argv*/ )
     /* VULKAN_KEY_START */
 
     // Check disk for existing cache data
-    size_t startCacheSize = 0;
-    char * startCacheData = nullptr;
+    std::vector<char> startCacheData;
 
     std::string   cacheFileName = "pipeline_cache_data.bin";
     std::ifstream readCacheStream( cacheFileName, std::ios_base::in | std::ios_base::binary );
@@ -149,14 +148,14 @@ int main( int /*argc*/, char ** /*argv*/ )
     {
       // Determine cache size
       readCacheStream.seekg( 0, readCacheStream.end );
-      startCacheSize = static_cast<size_t>( readCacheStream.tellg() );
+      size_t startCacheSize = static_cast<size_t>( readCacheStream.tellg() );
       readCacheStream.seekg( 0, readCacheStream.beg );
 
       // Allocate memory to hold the initial cache data
-      startCacheData = (char *)std::malloc( startCacheSize );
+      startCacheData.resize( startCacheSize );
 
       // Read the data into our buffer
-      readCacheStream.read( startCacheData, startCacheSize );
+      readCacheStream.read( startCacheData.data(), startCacheData.size() );
 
       // Clean up and print results
       readCacheStream.close();
@@ -169,7 +168,7 @@ int main( int /*argc*/, char ** /*argv*/ )
       std::cout << "  Pipeline cache miss!\n";
     }
 
-    if ( startCacheData != nullptr )
+    if ( !startCacheData.empty() )
     {
       // Check for cache validity
       //
@@ -205,11 +204,12 @@ int main( int /*argc*/, char ** /*argv*/ )
       uint32_t deviceID                        = 0;
       uint8_t  pipelineCacheUUID[VK_UUID_SIZE] = {};
 
-      memcpy( &headerLength, (uint8_t *)startCacheData + 0, 4 );
-      memcpy( &cacheHeaderVersion, (uint8_t *)startCacheData + 4, 4 );
-      memcpy( &vendorID, (uint8_t *)startCacheData + 8, 4 );
-      memcpy( &deviceID, (uint8_t *)startCacheData + 12, 4 );
-      memcpy( pipelineCacheUUID, (uint8_t *)startCacheData + 16, VK_UUID_SIZE );
+      uint8_t * startCacheDataPtr = reinterpret_cast<uint8_t *>( startCacheData.data() );
+      memcpy( &headerLength, startCacheDataPtr + 0, 4 );
+      memcpy( &cacheHeaderVersion, startCacheDataPtr + 4, 4 );
+      memcpy( &vendorID, startCacheDataPtr + 8, 4 );
+      memcpy( &deviceID, startCacheDataPtr + 12, 4 );
+      memcpy( pipelineCacheUUID, startCacheDataPtr + 16, VK_UUID_SIZE );
 
       // Check each field and report bad values before freeing existing cache
       bool badCache = false;
@@ -255,9 +255,7 @@ int main( int /*argc*/, char ** /*argv*/ )
       if ( badCache )
       {
         // Don't submit initial cache data if any version info is incorrect
-        free( startCacheData );
-        startCacheSize = 0;
-        startCacheData = nullptr;
+        startCacheData.clear();
 
         // And clear out the old cache file for use in next run
         std::cout << "  Deleting cache entry " << cacheFileName << " to repopulate.\n";
@@ -271,11 +269,10 @@ int main( int /*argc*/, char ** /*argv*/ )
 
     // Feed the initial cache data into cache creation
     vk::PipelineCache pipelineCache =
-      device.createPipelineCache( vk::PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags(), startCacheSize, startCacheData ) );
+      device.createPipelineCache( vk::PipelineCacheCreateInfo( vk::PipelineCacheCreateFlags(), startCacheData.size(), startCacheData.data() ) );
 
     // Free our initialData now that pipeline cache has been created
-    free( startCacheData );
-    startCacheData = NULL;
+    startCacheData.clear();
 
     // Time (roughly) taken to create the graphics pipeline
     timestamp_t  start            = getMilliseconds();

samples/SharedHandles/SharedHandles.cpp

@@ -86,7 +86,7 @@ public:
     VkResult     err = glfwCreateWindowSurface( instance.get(), window.handle, nullptr, &surface );
     if ( err != VK_SUCCESS )
       throw std::runtime_error( "Failed to create window!" );
-    vk::SharedSurfaceKHR sharedSurface{ static_cast<vk::SurfaceKHR>(surface), instance };
+    vk::SharedSurfaceKHR sharedSurface{ static_cast<vk::SurfaceKHR>( surface ), instance };
 
     auto graphicsAndPresentQueueFamilyIndex = vk::su::findGraphicsAndPresentQueueFamilyIndex( physicalDevice, sharedSurface.get() );
     device = vk::SharedDevice{ vk::su::createDevice( physicalDevice, graphicsAndPresentQueueFamilyIndex.first, vk::su::getDeviceExtensions() ) };
@@ -109,16 +109,12 @@ public:
     std::transform( swapChainData.images.begin(),
                     swapChainData.images.end(),
                     std::back_inserter( images ),
-                    [this]( vk::Image image ) {
-                      return vk::SharedImage{ image, device, vk::SwapchainOwns::yes };
-                    } );
+                    [this]( vk::Image image ) { return vk::SharedImage{ image, device, vk::SwapchainOwns::yes }; } );
 
     std::transform( swapChainData.imageViews.begin(),
                     swapChainData.imageViews.end(),
                     std::back_inserter( imageViews ),
-                    [this]( vk::ImageView imageView ) {
-                      return vk::SharedImageView{ imageView, device };
-                    } );
+                    [this]( vk::ImageView imageView ) { return vk::SharedImageView{ imageView, device }; } );
     commandPool =
       vk::SharedCommandPool{ device->createCommandPool( { vk::CommandPoolCreateFlagBits::eResetCommandBuffer, graphicsAndPresentQueueFamilyIndex.first } ),
                              device };
@@ -230,9 +226,9 @@ public:
     vk::Result result = presentQueue->presentKHR( vk::PresentInfoKHR( {}, swap, currentBuffer ) );
     switch ( result )
     {
-      case vk::Result::eSuccess: break;
+      case vk::Result::eSuccess      : break;
       case vk::Result::eSuboptimalKHR: std::cout << "vk::Queue::presentKHR returned vk::Result::eSuboptimalKHR !\n"; break;
-      default: assert( false );  // an unexpected result is returned !
+      default                        : assert( false );  // an unexpected result is returned !
     }
     std::this_thread::sleep_for( std::chrono::milliseconds( 1000 ) );
 

snippets/CppmTemplate.hpp

@@ -12,12 +12,7 @@ module;
   "\tTo silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n" \
   "\tFor feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues"
 
-
-#  if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
-_Pragma(VULKAN_HPP_STRINGIFY(GCC warning VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING))
-#  elif defined(_MSC_VER)
-_Pragma(VULKAN_HPP_STRINGIFY(message(__FILE__ "(" VULKAN_HPP_STRINGIFY(__LINE__) "): warning: " VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING)))
-#  endif
+  VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING )
 #endif
 
 #include <vulkan/${api}.hpp>
@@ -28,7 +23,7 @@ _Pragma(VULKAN_HPP_STRINGIFY(message(__FILE__ "(" VULKAN_HPP_STRINGIFY(__LINE__)
 #include <vulkan/${api}_shared.hpp>
 
 export module ${api}_hpp;
-export import VULKAN_HPP_STD_MODULE;
+export import std;
 
 export namespace VULKAN_HPP_NAMESPACE
 {

snippets/DispatchLoaderBase.hpp

@@ -20,3 +20,10 @@
     bool   m_valid         = true;
 #endif
   };
+  
+  template <typename Type>
+  struct isDispatchLoader
+  {
+    static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
+  };
+  

snippets/DynamicLoader.hpp

@@ -101,9 +101,9 @@
     T getProcAddress( const char* function ) const VULKAN_HPP_NOEXCEPT
     {
 #  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined(__Fuchsia__)
-      return (T)dlsym( m_library, function );
+      return (T)(void*)dlsym( m_library, function );
 #  elif defined( _WIN32 )
-      return (T)::GetProcAddress( m_library, function );
+      return (T)(void*)::GetProcAddress( m_library, function );
 #  else
 #    error unsupported platform
 #  endif

snippets/ExtensionInspectionHppTemplate.hpp

@@ -68,7 +68,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
 #if !defined( NDEBUG )
     static std::set<std::string> versions = { ${versions} };
-    assert( versions.find( version ) != versions.end() );
+    VULKAN_HPP_ASSERT( versions.find( version ) != versions.end() );
 #endif
     static std::vector<std::vector<std::string>> noDependencies;
 

snippets/HppTemplate.hpp

@@ -4,7 +4,7 @@ ${licenseHeader}
 
 ${includes}
 
-static_assert( VK_HEADER_VERSION == ${headerVersion}, "Wrong VK_HEADER_VERSION!" );
+VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == ${headerVersion}, "Wrong VK_HEADER_VERSION!" );
 
 ${defines}
 

snippets/MacrosHppTemplate.hpp

@@ -30,6 +30,20 @@ ${licenseHeader}
 #  include <ciso646>
 #endif
 
+#define VULKAN_HPP_STRINGIFY2( text ) #text
+#define VULKAN_HPP_STRINGIFY( text )  VULKAN_HPP_STRINGIFY2( text )
+#define VULKAN_HPP_NAMESPACE_STRING   VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
+
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+#  define VULKAN_HPP_COMPILE_WARNING( text ) \
+     _Pragma( VULKAN_HPP_STRINGIFY( GCC warning text ))
+#elif defined(_MSC_VER)
+#  define VULKAN_HPP_COMPILE_WARNING( text ) \
+     _Pragma( VULKAN_HPP_STRINGIFY( message(__FILE__ "(" VULKAN_HPP_STRINGIFY(__LINE__) "): warning: " text )))
+#else
+#  define VULKAN_HPP_COMPILE_WARNING( text )
+#endif
+
 #if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
 #  if !defined( VULKAN_HPP_NO_SMART_HANDLE )
 #    define VULKAN_HPP_NO_SMART_HANDLE
@@ -82,8 +96,8 @@ ${licenseHeader}
 #  define VULKAN_HPP_SUPPORT_SPAN
 #endif
 
-#if !defined( VULKAN_HPP_STD_MODULE ) && defined( VULKAN_HPP_CXX_MODULE )
-#  define VULKAN_HPP_STD_MODULE std.compat
+#if defined( VULKAN_HPP_CXX_MODULE ) && !( defined( __cpp_modules ) && defined( __cpp_lib_modules ) )
+VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ named modules and the standard library module." )
 #endif
 
 ${vulkan_64_bit_ptr_defines}
@@ -213,10 +227,6 @@ ${vulkan_64_bit_ptr_defines}
 #  define VULKAN_HPP_NAMESPACE vk
 #endif
 
-#define VULKAN_HPP_STRINGIFY2( text ) #text
-#define VULKAN_HPP_STRINGIFY( text )  VULKAN_HPP_STRINGIFY2( text )
-#define VULKAN_HPP_NAMESPACE_STRING   VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
-
 #if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
 #  if defined( VK_NO_PROTOTYPES )
 #    define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
@@ -295,16 +305,11 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
 #if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
-#  define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
-#  define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
-#  define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
 #  define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment )
 #else
-#  define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT                     = {}
-#  define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT             = nullptr
-#  define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT                   = VULKAN_HPP_DEFAULT_DISPATCHER
 #  define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) = assignment
 #endif
+#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT  VULKAN_HPP_DEFAULT_ASSIGNMENT( VULKAN_HPP_DEFAULT_DISPATCHER )
 
 #if !defined( VULKAN_HPP_RAII_NAMESPACE )
 #  define VULKAN_HPP_RAII_NAMESPACE raii

snippets/ObjectDestroy.hpp

@@ -5,7 +5,7 @@ public:
   ObjectDestroy() = default;
 
   ObjectDestroy( OwnerType                           owner,
-                 Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                 Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
                  Dispatch const & dispatch           VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
     : m_owner( owner )
     , m_allocationCallbacks( allocationCallbacks )

snippets/ObjectFree.hpp

@@ -5,7 +5,7 @@
     ObjectFree() = default;
 
     ObjectFree( OwnerType                           owner,
-                Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+                Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
                 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
       : m_owner( owner )
       , m_allocationCallbacks( allocationCallbacks )

snippets/ResultValue.hpp

@@ -35,25 +35,25 @@
 
     T const * operator->() const VULKAN_HPP_NOEXCEPT
     {
-      assert( has_value() );
+      VULKAN_HPP_ASSERT( has_value() );
       return &value;
     }
 
     T * operator->() VULKAN_HPP_NOEXCEPT
     {
-      assert( has_value() );
+      VULKAN_HPP_ASSERT( has_value() );
       return &value;
     }
 
     T const & operator*() const VULKAN_HPP_NOEXCEPT
     {
-      assert(has_value ());
+      VULKAN_HPP_ASSERT(has_value ());
       return value;
     }
 
     T & operator*() VULKAN_HPP_NOEXCEPT
     {
-      assert(has_value ());
+      VULKAN_HPP_ASSERT(has_value ());
       return value;
     }
   };

snippets/SharedHppTemplate.hpp

@@ -317,13 +317,12 @@ namespace VULKAN_HPP_NAMESPACE
 #    pragma clang diagnostic ignored "-Wcast-function-type"
 #  endif
 
-    template <typename HandleType>
+    template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     class ObjectDestroyShared
     {
     public:
       using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
 
-      template <class Dispatcher>
       using DestroyFunctionPointerType =
         typename std::conditional<HasDestructor<HandleType>::value,
                                   void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
@@ -331,10 +330,9 @@ namespace VULKAN_HPP_NAMESPACE
 
       using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
 
-      template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-      ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
                            const Dispatcher & dispatch         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &SelectorType::destroy ) ) )
         , m_dispatch( &dispatch )
         , m_allocationCallbacks( allocationCallbacks )
       {
@@ -356,24 +354,22 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy             = nullptr;
-      const detail::DispatchLoaderBase *                     m_dispatch            = nullptr;
+      DestroyFunctionPointerType          m_destroy             = nullptr;
+      const Dispatcher *                  m_dispatch            = nullptr;
       Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
     };
 
-    template <typename HandleType>
+    template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     class ObjectFreeShared
     {
     public:
       using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
 
-      template <class Dispatcher>
       using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
 
-      template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-      ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
                         const Dispatcher & dispatch         VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::free ) ) )
         , m_dispatch( &dispatch )
         , m_allocationCallbacks( allocationCallbacks )
       {
@@ -387,23 +383,21 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy             = nullptr;
-      const detail::DispatchLoaderBase *                     m_dispatch            = nullptr;
+      DestroyFunctionPointerType          m_destroy             = nullptr;
+      const Dispatcher *                  m_dispatch            = nullptr;
       Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
     };
 
-    template <typename HandleType>
+    template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     class ObjectReleaseShared
     {
     public:
       using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
 
-      template <class Dispatcher>
       using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
 
-      template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
       ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::release ) ) )
         , m_dispatch( &dispatch )
       {
       }
@@ -416,11 +410,11 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy  = nullptr;
-      const detail::DispatchLoaderBase *                     m_dispatch = nullptr;
+      DestroyFunctionPointerType m_destroy  = nullptr;
+      const Dispatcher *         m_dispatch = nullptr;
     };
 
-    template <typename HandleType, typename PoolType>
+    template <typename HandleType, typename PoolType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     class PoolFreeShared
     {
     public:
@@ -428,17 +422,14 @@ namespace VULKAN_HPP_NAMESPACE
 
       using PoolTypeExport = PoolType;
 
-      template <class Dispatcher>
       using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
 
-      template <class Dispatcher>
-      using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
+      using DestroyFunctionPointerType = ReturnType( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
 
       PoolFreeShared() = default;
 
-      template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
       PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::free ) ) )
         , m_dispatch( &dispatch )
         , m_pool( std::move( pool ) )
       {
@@ -452,8 +443,8 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy  = nullptr;
-      const detail::DispatchLoaderBase *                     m_dispatch = nullptr;
+      DestroyFunctionPointerType m_destroy  = nullptr;
+      const Dispatcher *         m_dispatch = nullptr;
       SharedHandle<PoolType>     m_pool{};
     };
 

snippets/StructsHppTemplate.hpp

@@ -8,7 +8,6 @@ ${licenseHeader}
 
 #if !defined( VULKAN_HPP_CXX_MODULE )
 #  include <cstring>  // strcmp
-#  include <cstdlib>  // free
 #endif
 
 namespace VULKAN_HPP_NAMESPACE

snippets/StructureChain.hpp

@@ -55,13 +55,13 @@
   public:
     StructureChain() VULKAN_HPP_NOEXCEPT
     {
-      static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+      VULKAN_HPP_STATIC_ASSERT( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
       link<sizeof...( ChainElements ) - 1>();
     }
 
     StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( rhs )
     {
-      static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+      VULKAN_HPP_STATIC_ASSERT( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
       link( &std::get<0>( *this ),
             &std::get<0>( rhs ),
             reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
@@ -70,7 +70,7 @@
 
     StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( elems... )
     {
-      static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+      VULKAN_HPP_STATIC_ASSERT( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
       link<sizeof...( ChainElements ) - 1>();
     }
 
@@ -130,7 +130,7 @@
     typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), bool>::type
       isLinked() const VULKAN_HPP_NOEXCEPT
     {
-      static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
+      VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
       return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
     }
 
@@ -138,7 +138,7 @@
     typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
       relink() VULKAN_HPP_NOEXCEPT
     {
-      static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
+      VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
       auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
       VULKAN_HPP_ASSERT( !isLinked( pNext ) );
       auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
@@ -150,7 +150,7 @@
     typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
       unlink() VULKAN_HPP_NOEXCEPT
     {
-      static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
+      VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
       unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
     }
 

snippets/includes.hpp

@@ -1,3 +1,4 @@
+#include <vulkan/${vulkan_h}>
 #if !defined( VULKAN_HPP_CXX_MODULE )
 // clang-format off
 #  include <vulkan/vulkan_hpp_macros.hpp>
@@ -27,10 +28,8 @@
 #else
 #  include <cassert>
 #  include <cstring>
-#  include <cstdlib>
-import VULKAN_HPP_STD_MODULE;
+import std;
 #endif
-#include <vulkan/${vulkan_h}>
 
 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
 #  if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )

tests/ArrayProxy/ArrayProxy.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 // no need to ignore any warnings with MSVC
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"
@@ -231,12 +232,12 @@ int main( int /*argc*/, char ** /*argv*/ )
   catch ( vk::SystemError const & err )
   {
     std::cout << "vk::SystemError: " << err.what() << std::endl;
-    exit( -1 );
+    std::exit( -1 );
   }
   catch ( ... )
   {
     std::cout << "unknown error\n";
-    exit( -1 );
+    std::exit( -1 );
   }
 
   return 0;

tests/ArrayProxyNoTemporaries/ArrayProxyNoTemporaries.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 // no need to ignore any warnings with MSVC
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"
@@ -237,12 +238,12 @@ int main( int /*argc*/, char ** /*argv*/ )
   catch ( vk::SystemError const & err )
   {
     std::cout << "vk::SystemError: " << err.what() << std::endl;
-    exit( -1 );
+    std::exit( -1 );
   }
   catch ( ... )
   {
     std::cout << "unknown error\n";
-    exit( -1 );
+    std::exit( -1 );
   }
 
   return 0;

tests/CMakeLists.txt

@@ -40,6 +40,7 @@ vulkan_hpp__setup_test( NAME FunctionCallsRAII )
 vulkan_hpp__setup_test( NAME Handles )
 vulkan_hpp__setup_test( NAME HandlesMoveExchange )
 vulkan_hpp__setup_test( NAME Hash )
+vulkan_hpp__setup_test( NAME NoDefaultDispatcher )
 if( ( CMAKE_CXX_STANDARD GREATER_EQUAL 23 ) AND NOT ( ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" ) AND ( CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0 ) ) )
 	vulkan_hpp__setup_test( NAME NoExceptionsRAII ) # errors with clang++13 and clang++14
 endif()
@@ -77,6 +78,7 @@ if( VULKAN_HPP_TESTS_CTEST AND VULKAN_HPP_BUILD_CXX_MODULE )
 	# vulkan_hpp__setup_test( NAME Handles CXX_MODULE ) # errors using equality operator with raii handles
 	vulkan_hpp__setup_test( NAME HandlesMoveExchange CXX_MODULE )
 	vulkan_hpp__setup_test( NAME Hash CXX_MODULE )
+	vulkan_hpp__setup_test( NAME NoDefaultDispatcher CXX_MODULE )
 	vulkan_hpp__setup_test( NAME NoExceptions CXX_MODULE )
 	vulkan_hpp__setup_test( NAME NoExceptionsRAII CXX_MODULE )
 	vulkan_hpp__setup_test( NAME StructureChain CXX_MODULE )

tests/DesignatedInitializers/DesignatedInitializers.cpp

@@ -16,6 +16,7 @@
 //                   Compile test on using designated initializers
 
 #ifdef VULKAN_HPP_USE_CXX_MODULE
+#  include <cstdint>
 import vulkan_hpp;
 #else
 #  include <cstdint>

tests/DispatchLoaderDynamic/DispatchLoaderDynamic.cpp

@@ -64,12 +64,12 @@ int main( int /*argc*/, char ** /*argv*/ )
   catch ( vk::SystemError const & err )
   {
     std::cout << "vk::SystemError: " << err.what() << std::endl;
-    exit( -1 );
+    std::exit( -1 );
   }
   catch ( ... )
   {
     std::cout << "unknown error\n";
-    exit( -1 );
+    std::exit( -1 );
   }
 
   return 0;

tests/EnableBetaExtensions/EnableBetaExtensions.cpp

@@ -18,6 +18,9 @@
 // ignore warning 4189: local variable is initialized but not referenced
 #if defined( _MSC_VER )
 #  pragma warning( disable : 4189 )
+#endif
+#if defined( __clang__ )
+#  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"
 #  pragma GCC diagnostic ignored "-Wunused-variable"

tests/ExtensionInspection/ExtensionInspection.cpp

@@ -17,9 +17,10 @@
 
 // ignore warning 4189: local variable is initialized but not referenced
 #if defined( _MSC_VER )
-#  pragma warning( disable : 4189 ) // unused variable warning
-#  pragma warning( disable : 4996 ) // deprecation warning
-#elif defined( __clang__ )
+#  pragma warning( disable : 4189 )
+#  pragma warning( disable : 4996 )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #  pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #elif defined( __GNUC__ )

tests/Flags/Flags.cpp

@@ -20,7 +20,12 @@
 
 // in this test, we ignore some warnings
 // You should not do that in production code !!
-#if defined( __GNUC__ )
+#if defined( _MSC_VER )
+// no need to ignore any warnings with MSVC
+#endif
+#if defined( __clang__ )
+#  pragma clang diagnostic ignored "-Wunused-variable"
+#elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-variable"
 #else
 // unknow compiler... just ignore the warnings for yourselves ;)

tests/FormatTraits/FormatTraits.cpp

@@ -18,10 +18,10 @@
 #ifdef VULKAN_HPP_USE_CXX_MODULE
 import vulkan_hpp;
 #else
-#  include <map>
-#  include <set>
 #  include <cstring>
 #  include <iostream>
+#  include <map>
+#  include <set>
 #  include <vulkan/vulkan_format_traits.hpp>
 #endif
 

tests/FunctionCalls/FunctionCalls.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 #  pragma warning( disable : 4189 )  // local variable is initialized but not referenced
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-variable"
@@ -315,6 +316,288 @@ int main( int /*argc*/, char ** /*argv*/ )
     device.waitIdle();
   }
 
+  // Memory commands
+  {
+    vk::Device             device;
+    vk::MemoryAllocateInfo memoryAllocateInfo;
+    vk::DeviceMemory       memory;
+    vk::Result             result = device.allocateMemory( &memoryAllocateInfo, nullptr, &memory );
+  }
+  {
+    vk::Device             device;
+    vk::MemoryAllocateInfo memoryAllocateInfo;
+    vk::DeviceMemory       memory = device.allocateMemory( memoryAllocateInfo );
+  }
+
+  {
+    vk::Device       device;
+    vk::DeviceMemory memory;
+    device.freeMemory( memory );
+  }
+
+  {
+    vk::Device         device;
+    vk::DeviceMemory   memory;
+    vk::DeviceSize     offset         = 0;
+    vk::DeviceSize     size           = vk::WholeSize;
+    vk::MemoryMapFlags memoryMapFlags = {};
+    void *             pData;
+    vk::Result         result = device.mapMemory( memory, offset, size, memoryMapFlags, &pData );
+  }
+  {
+    vk::Device         device;
+    vk::DeviceMemory   memory;
+    vk::DeviceSize     offset         = 0;
+    vk::DeviceSize     size           = vk::WholeSize;
+    vk::MemoryMapFlags memoryMapFlags = {};
+    void *             pData          = device.mapMemory( memory, offset, size, memoryMapFlags );
+  }
+
+  {
+    vk::Device       device;
+    vk::DeviceMemory memory;
+    device.unmapMemory( memory );
+  }
+
+  {
+    vk::Device            device;
+    vk::DeviceMemory      memory;
+    vk::MappedMemoryRange mappedMemoryRange;
+    vk::Result            result = device.flushMappedMemoryRanges( 1, &mappedMemoryRange );
+  }
+  {
+    vk::Device                         device;
+    std::vector<vk::MappedMemoryRange> mappedMemoryRanges;
+    device.flushMappedMemoryRanges( mappedMemoryRanges );
+  }
+
+  {
+    vk::Device            device;
+    vk::MappedMemoryRange mappedMemoryRange;
+    vk::Result            result = device.invalidateMappedMemoryRanges( 1, &mappedMemoryRange );
+  }
+  {
+    vk::Device                         device;
+    std::vector<vk::MappedMemoryRange> mappedMemoryRanges;
+    device.invalidateMappedMemoryRanges( mappedMemoryRanges );
+  }
+
+  {
+    vk::Device       device;
+    vk::DeviceMemory memory;
+    vk::DeviceSize   commitment;
+    device.getMemoryCommitment( memory, &commitment );
+  }
+  {
+    vk::Device       device;
+    vk::DeviceMemory memory;
+    vk::DeviceSize   commitment = device.getMemoryCommitment( memory );
+  }
+
+  // Memory management API commands
+  {
+    vk::Device       device;
+    vk::Buffer       buffer;
+    vk::DeviceMemory deviceMemory;
+    vk::DeviceSize   memoryOffset = 0;
+    device.bindBufferMemory( buffer, deviceMemory, memoryOffset );
+  }
+
+  {
+    vk::Device       device;
+    vk::Image        image;
+    vk::DeviceMemory deviceMemory;
+    vk::DeviceSize   memoryOffset = 0;
+    device.bindImageMemory( image, deviceMemory, memoryOffset );
+  }
+
+  {
+    vk::Device             device;
+    vk::Buffer             buffer;
+    vk::MemoryRequirements memoryRequirements;
+    device.getBufferMemoryRequirements( buffer, &memoryRequirements );
+  }
+  {
+    vk::Device             device;
+    vk::Buffer             buffer;
+    vk::MemoryRequirements memoryRequirements = device.getBufferMemoryRequirements( buffer );
+  }
+
+  {
+    vk::Device             device;
+    vk::Image              image;
+    vk::MemoryRequirements memoryRequirements;
+    device.getImageMemoryRequirements( image, &memoryRequirements );
+  }
+  {
+    vk::Device             device;
+    vk::Image              image;
+    vk::MemoryRequirements memoryRequirements = device.getImageMemoryRequirements( image );
+  }
+
+  // Sparse resource memory management API commands (optional)
+  {
+    vk::Device device;
+    vk::Image  image;
+    uint32_t   sparseMemoryRequirementCount;
+    device.getImageSparseMemoryRequirements( image, &sparseMemoryRequirementCount, nullptr );
+    if ( sparseMemoryRequirementCount )
+    {
+      std::vector<vk::SparseImageMemoryRequirements> sparseImageMemoryRequirements( sparseMemoryRequirementCount );
+      device.getImageSparseMemoryRequirements( image, &sparseMemoryRequirementCount, sparseImageMemoryRequirements.data() );
+    }
+  }
+  {
+    vk::Device                                     device;
+    vk::Image                                      image;
+    std::vector<vk::SparseImageMemoryRequirements> sparseImageMemoryRequirementss = device.getImageSparseMemoryRequirements( image );
+  }
+  {
+    vk::Device device;
+    vk::Image  image;
+    using Allocator = std::allocator<vk::SparseImageMemoryRequirements>;
+    Allocator                                                 allocator;
+    std::vector<vk::SparseImageMemoryRequirements, Allocator> sparseImageMemoryRequirementss = device.getImageSparseMemoryRequirements( image, allocator );
+  }
+
+  {
+    vk::PhysicalDevice      physicalDevice;
+    vk::Format              format        = {};
+    vk::ImageType           type          = {};
+    vk::SampleCountFlagBits samples       = {};
+    vk::ImageUsageFlags     usage         = {};
+    vk::ImageTiling         tiling        = {};
+    uint32_t                propertyCount = 0;
+    physicalDevice.getSparseImageFormatProperties( format, type, samples, usage, tiling, &propertyCount, nullptr );
+    if ( propertyCount )
+    {
+      std::vector<vk::SparseImageFormatProperties> sparseImageFormatProperties( propertyCount );
+      physicalDevice.getSparseImageFormatProperties( format, type, samples, usage, tiling, &propertyCount, sparseImageFormatProperties.data() );
+    }
+  }
+  {
+    vk::PhysicalDevice                           physicalDevice;
+    vk::Format                                   format  = {};
+    vk::ImageType                                type    = {};
+    vk::SampleCountFlagBits                      samples = {};
+    vk::ImageUsageFlags                          usage   = {};
+    vk::ImageTiling                              tiling  = {};
+    std::vector<vk::SparseImageFormatProperties> sparseImageFormatProperties =
+      physicalDevice.getSparseImageFormatProperties( format, type, samples, usage, tiling );
+  }
+  {
+    vk::PhysicalDevice      physicalDevice;
+    vk::Format              format  = {};
+    vk::ImageType           type    = {};
+    vk::SampleCountFlagBits samples = {};
+    vk::ImageUsageFlags     usage   = {};
+    vk::ImageTiling         tiling  = {};
+    using Allocator                 = std::allocator<vk::SparseImageFormatProperties>;
+    Allocator                                               allocator;
+    std::vector<vk::SparseImageFormatProperties, Allocator> sparseImageFormatProperties =
+      physicalDevice.getSparseImageFormatProperties( format, type, samples, usage, tiling, allocator );
+  }
+
+  {
+    vk::Queue          queue;
+    uint32_t           bindInfoCount = 1;
+    vk::BindSparseInfo bindSparseInfo;
+    vk::Fence          fence;
+    vk::Result         result = queue.bindSparse( bindInfoCount, &bindSparseInfo, fence );
+  }
+
+  {
+    vk::Queue          queue;
+    vk::BindSparseInfo bindSparseInfo;
+    vk::Fence          fence;
+    queue.bindSparse( bindSparseInfo, fence );
+  }
+
+  // Fence commands
+  {
+    vk::Device              device;
+    vk::FenceCreateInfo     fenceCreateInfo;
+    vk::AllocationCallbacks allocationCallbacks;
+    vk::Fence               fence;
+    vk::Result              result = device.createFence( &fenceCreateInfo, &allocationCallbacks, &fence );
+  }
+  {
+    vk::Device          device;
+    vk::FenceCreateInfo fenceCreateInfo;
+    vk::Fence           fence = device.createFence( fenceCreateInfo );
+  }
+
+  {
+    vk::Device              device;
+    vk::Fence               fence;
+    vk::AllocationCallbacks allocationCallbacks;
+    device.destroyFence( fence, &allocationCallbacks );
+  }
+  {
+    vk::Device device;
+    vk::Fence  fence;
+    device.destroyFence( fence );
+  }
+
+  {
+    vk::Device device;
+    uint32_t   fenceCount = 1;
+    vk::Fence  fence;
+    vk::Result result = device.resetFences( fenceCount, &fence );
+  }
+  {
+    vk::Device device;
+    vk::Fence  fence;
+    device.resetFences( fence );
+  }
+
+  {
+    vk::Device device;
+    vk::Fence  fence;
+    vk::Result result = device.getFenceStatus( fence );
+  }
+
+  {
+    vk::Device device;
+    uint32_t   fenceCount = 1;
+    vk::Fence  fence;
+    vk::Bool32 waitAll = vk::True;
+    uint64_t   timeout = 1000000000;
+    vk::Result result  = device.waitForFences( fenceCount, &fence, waitAll, timeout );
+  }
+  {
+    vk::Device device;
+    vk::Fence  fence;
+    vk::Bool32 waitAll = vk::True;
+    uint64_t   timeout = 1000000000;
+    vk::Result result  = device.waitForFences( fence, waitAll, timeout );
+  }
+
+  // Queue semaphore commands
+  {
+    vk::Device              device;
+    vk::SemaphoreCreateInfo semaphoreCreateInfo;
+    vk::Semaphore           semaphore;
+    vk::Result              result = device.createSemaphore( &semaphoreCreateInfo, nullptr, &semaphore );
+  }
+  {
+    vk::Device              device;
+    vk::SemaphoreCreateInfo semaphoreCreateInfo;
+    vk::Semaphore           semaphore = device.createSemaphore( semaphoreCreateInfo );
+  }
+
+  {
+    vk::Device              device;
+    vk::Semaphore           semaphore;
+    vk::AllocationCallbacks allocationCallbacks;
+    device.destroySemaphore( semaphore, &allocationCallbacks );
+  }
+  {
+    vk::Device    device;
+    vk::Semaphore semaphore;
+    device.destroySemaphore( semaphore );
+  }
+
 #if 0
   {
     vk::PhysicalDevice physicalDevice;

tests/FunctionCallsRAII/FunctionCallsRAII.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 #  pragma warning( disable : 4189 )  // local variable is initialized but not referenced
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-variable"
@@ -27,6 +28,7 @@
 #endif
 
 #ifdef VULKAN_HPP_USE_CXX_MODULE
+#  include <cstdint>
 import vulkan_hpp;
 #else
 #  include <vulkan/vulkan_raii.hpp>
@@ -109,6 +111,11 @@ int main( int /*argc*/, char ** /*argv*/ )
     vk::DeviceCreateInfo     deviceCreateInfo;
     vk::raii::Device         device = physicalDevice.createDevice( deviceCreateInfo );
   }
+  {
+    vk::raii::PhysicalDevice physicalDevice = nullptr;
+    vk::DeviceCreateInfo     deviceCreateInfo;
+    vk::raii::Device         device( physicalDevice, deviceCreateInfo );
+  }
 
   // Extension discovery commands
   {
@@ -139,6 +146,12 @@ int main( int /*argc*/, char ** /*argv*/ )
     uint32_t         queueIndex       = 0;
     vk::raii::Queue  queue            = device.getQueue( queueFamilyIndex, queueIndex );
   }
+  {
+    vk::raii::Device device           = nullptr;
+    uint32_t         queueFamilyIndex = 0;
+    uint32_t         queueIndex       = 0;
+    vk::raii::Queue  queue( device, queueFamilyIndex, queueIndex );
+  }
 
   {
     vk::raii::Queue queue = nullptr;
@@ -157,5 +170,139 @@ int main( int /*argc*/, char ** /*argv*/ )
     device.waitIdle();
   }
 
+  // Memory commands
+  {
+    vk::raii::Device       device = nullptr;
+    vk::MemoryAllocateInfo memoryAllocateInfo;
+    vk::raii::DeviceMemory deviceMemory = device.allocateMemory( memoryAllocateInfo );
+  }
+  {
+    vk::raii::Device       device = nullptr;
+    vk::MemoryAllocateInfo memoryAllocateInfo;
+    vk::raii::DeviceMemory deviceMemory( device, memoryAllocateInfo );
+  }
+
+  {
+    vk::raii::DeviceMemory deviceMemory   = nullptr;
+    vk::DeviceSize         offset         = 0;
+    vk::DeviceSize         size           = vk::WholeSize;
+    vk::MemoryMapFlags     memoryMapFlags = {};
+    void *                 pData          = deviceMemory.mapMemory( offset, size, memoryMapFlags );
+  }
+
+  {
+    vk::raii::DeviceMemory deviceMemory = nullptr;
+    deviceMemory.unmapMemory();
+  }
+
+  {
+    vk::raii::Device                   device = nullptr;
+    std::vector<vk::MappedMemoryRange> mappedMemoryRanges;
+    device.flushMappedMemoryRanges( mappedMemoryRanges );
+  }
+
+  {
+    vk::raii::Device                   device = nullptr;
+    std::vector<vk::MappedMemoryRange> mappedMemoryRanges;
+    device.invalidateMappedMemoryRanges( mappedMemoryRanges );
+  }
+
+  {
+    vk::raii::DeviceMemory deviceMemory = nullptr;
+    vk::DeviceSize         size         = deviceMemory.getCommitment();
+  }
+
+  // Memory management API commands
+  {
+    vk::raii::Buffer buffer = nullptr;
+    vk::DeviceMemory deviceMemory;
+    vk::DeviceSize   memoryOffset = 0;
+    buffer.bindMemory( deviceMemory, memoryOffset );
+  }
+
+  {
+    vk::raii::Image  image = nullptr;
+    vk::DeviceMemory deviceMemory;
+    vk::DeviceSize   memoryOffset = 0;
+    image.bindMemory( deviceMemory, memoryOffset );
+  }
+
+  {
+    vk::raii::Buffer       buffer             = nullptr;
+    vk::MemoryRequirements memoryRequirements = buffer.getMemoryRequirements();
+  }
+
+  {
+    vk::raii::Image        image              = nullptr;
+    vk::MemoryRequirements memoryRequirements = image.getMemoryRequirements();
+  }
+
+  // Sparse resource memory management API commands (optional)
+  {
+    vk::raii::Image                                image                         = nullptr;
+    std::vector<vk::SparseImageMemoryRequirements> sparseImageMemoryRequirements = image.getSparseMemoryRequirements();
+  }
+
+  {
+    vk::raii::PhysicalDevice                     physicalDevice = nullptr;
+    vk::Format                                   format         = {};
+    vk::ImageType                                type           = {};
+    vk::SampleCountFlagBits                      samples        = {};
+    vk::ImageUsageFlags                          usage          = {};
+    vk::ImageTiling                              tiling         = {};
+    std::vector<vk::SparseImageFormatProperties> sparseImageFormatProperties =
+      physicalDevice.getSparseImageFormatProperties( format, type, samples, usage, tiling );
+  }
+
+  {
+    vk::raii::Queue    queue = nullptr;
+    vk::BindSparseInfo bindSparseInfo;
+    vk::Fence          fence;
+    queue.bindSparse( bindSparseInfo, fence );
+  }
+
+  // Fence commands
+  {
+    vk::raii::Device    device = nullptr;
+    vk::FenceCreateInfo fenceCreateInfo;
+    vk::raii::Fence     fence = device.createFence( fenceCreateInfo );
+  }
+  {
+    vk::raii::Device    device = nullptr;
+    vk::FenceCreateInfo fenceCreateInfo;
+    vk::raii::Fence     fence( device, fenceCreateInfo );
+  }
+
+  {
+    vk::raii::Device device = nullptr;
+    vk::Fence        fence;
+    device.resetFences( fence );
+  }
+
+  {
+    vk::raii::Fence fence  = nullptr;
+    vk::Result      result = fence.getStatus();
+  }
+
+  {
+    vk::raii::Device device = nullptr;
+    vk::Fence        fence;
+    vk::Bool32       waitAll = vk::True;
+    uint64_t         timeout = 1000000000;
+    vk::Result       result  = device.waitForFences( fence, waitAll, timeout );
+  }
+
+  // Queue semaphore commands
+  {
+    vk::raii::Device        device = nullptr;
+    vk::SemaphoreCreateInfo semaphoreCreateInfo;
+    vk::raii::Semaphore     semaphore = device.createSemaphore( semaphoreCreateInfo );
+  }
+  {
+    vk::raii::Device        device = nullptr;
+    vk::SemaphoreCreateInfo semaphoreCreateInfo;
+    vk::raii::Semaphore     semaphore( device, semaphoreCreateInfo );
+  }
+
   return 0;
 }

tests/HandlesMoveExchange/HandlesMoveExchange.cpp

@@ -44,12 +44,12 @@ int main( int /*argc*/, char ** /*argv*/ )
   catch ( vk::SystemError const & err )
   {
     std::cout << "vk::SystemError: " << err.what() << std::endl;
-    exit( -1 );
+    std::exit( -1 );
   }
   catch ( ... )
   {
     std::cout << "unknown error\n";
-    exit( -1 );
+    std::exit( -1 );
   }
 
   return 0;

tests/Hash/Hash.cpp

@@ -17,6 +17,9 @@
 
 #if defined( _MSC_VER )
 #  pragma warning( disable : 4189 )  // local variable is initialized but not referenced
+#endif
+#if defined( __clang__ )
+#  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-variable"
 #else
@@ -124,12 +127,12 @@ int main( int /*argc*/, char ** /*argv*/ )
   catch ( vk::SystemError const & err )
   {
     std::cout << "vk::SystemError: " << err.what() << std::endl;
-    exit( -1 );
+    std::exit( -1 );
   }
   catch ( ... )
   {
     std::cout << "unknown error\n";
-    exit( -1 );
+    std::exit( -1 );
   }
 
   return 0;

tests/NoDefaultDispatcher/CMakeLists.txt

@@ -0,0 +1,20 @@
+# Copyright(c) 2018, NVIDIA CORPORATION. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+cmake_minimum_required( VERSION 3.12 )
+project( VulkanHppTest LANGUAGES CXX )
+
+set(VULKAN_HPP_NO_DEFAULT_DISPATCHER ON)
+include( ${CMAKE_CURRENT_SOURCE_DIR}/../../CMakeLists.txt )
+vulkan_hpp__setup_test_project()

tests/NoDefaultDispatcher/NoDefaultDispatcher.cpp

@@ -0,0 +1,29 @@
+// Copyright(c) 2018, NVIDIA CORPORATION. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// VulkanHpp Samples : NoDefaultDispatcher
+//                     Compile test with VULKAN_HPP_NO_DEFAULT_DISPATCHER defined
+
+#ifdef VULKAN_HPP_USE_CXX_MODULE
+import vulkan_hpp;
+#else
+#  include <vulkan/vulkan.hpp>
+#  include <vulkan/vulkan_raii.hpp>
+#  include <vulkan/vulkan_shared.hpp>
+#endif
+
+int main( int /*argc*/, char ** /*argv*/ )
+{
+  return 0;
+}

tests/NoExceptions/NoExceptions.cpp

@@ -17,6 +17,7 @@
 //                     Note: this is _no_ functional test!! Don't ever code this way!!
 
 #ifdef VULKAN_HPP_USE_CXX_MODULE
+#include <cstdint>
 import vulkan_hpp;
 #else
 #  include <vector>
@@ -50,7 +51,7 @@ int main( int /*argc*/, char ** /*argv*/ )
   std::vector<vk::QueueFamilyProperties> queueFamilyProperties = physicalDevices[0].getQueueFamilyProperties();
 
   // get the first index into queueFamiliyProperties which supports graphics
-  size_t graphicsQueueFamilyIndex =
+  std::size_t graphicsQueueFamilyIndex =
     std::distance( queueFamilyProperties.begin(),
                    std::find_if( queueFamilyProperties.begin(),
                                  queueFamilyProperties.end(),

tests/NoExceptionsRAII/NoExceptionsRAII.cpp

@@ -17,6 +17,7 @@
 //                     Note: this is _no_ functional test!! Don't ever code this way!!
 
 #ifdef VULKAN_HPP_USE_CXX_MODULE
+#  include <cstdint>
 import vulkan_hpp;
 #else
 #  include <vector>
@@ -45,7 +46,7 @@ int main( int /*argc*/, char ** /*argv*/ )
   std::vector<vk::QueueFamilyProperties> queueFamilyProperties = physicalDevice.getQueueFamilyProperties();
 
   // get the first index into queueFamiliyProperties which supports graphics
-  size_t graphicsQueueFamilyIndex =
+  std::size_t graphicsQueueFamilyIndex =
     std::distance( queueFamilyProperties.begin(),
                    std::find_if( queueFamilyProperties.begin(),
                                  queueFamilyProperties.end(),

tests/StridedArrayProxy/StridedArrayProxy.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 // no need to ignore any warnings with MSVC
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-but-set-variable"
@@ -240,12 +241,12 @@ int main( int /*argc*/, char ** /*argv*/ )
   catch ( vk::SystemError const & err )
   {
     std::cout << "vk::SystemError: " << err.what() << std::endl;
-    exit( -1 );
+    std::exit( -1 );
   }
   catch ( ... )
   {
     std::cout << "unknown error\n";
-    exit( -1 );
+    std::exit( -1 );
   }
 
   return 0;

tests/StructureChain/StructureChain.cpp

@@ -18,6 +18,9 @@
 // ignore warning 4189: local variable is initialized but not referenced
 #if defined( _MSC_VER )
 #  pragma warning( disable : 4189 )
+#endif
+#if defined( __clang__ )
+#  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-variable"
 #else
@@ -194,12 +197,12 @@ int main( int /*argc*/, char ** /*argv*/ )
   catch ( vk::SystemError const & err )
   {
     std::cout << "vk::SystemError: " << err.what() << std::endl;
-    exit( -1 );
+    std::exit( -1 );
   }
   catch ( ... )
   {
     std::cout << "unknown error\n";
-    exit( -1 );
+    std::exit( -1 );
   }
   return 0;
 }

tests/UniqueHandleDefaultArguments/UniqueHandleDefaultArguments.cpp

@@ -24,16 +24,18 @@ import vulkan_hpp;
 #endif
 
 #if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-namespace vk {
-  namespace detail {
+namespace vk
+{
+  namespace detail
+  {
     DispatchLoaderDynamic defaultDispatchLoaderDynamic;
-  }
-}
+  }  // namespace detail
+}  // namespace vk
 #endif
 
 int main( int /*argc*/, char ** /*argv*/ )
 {
   VkSurfaceKHR surface       = 0;
-  auto         uniqueSurface = vk::UniqueSurfaceKHR( surface, vk::Instance() );
+  auto         uniqueSurface = vk::UniqueSurfaceKHR( static_cast<vk::SurfaceKHR>( surface ), vk::Instance() );
   return 0;
 }

tests/Video/Video.cpp

@@ -17,7 +17,8 @@
 
 #if defined( _MSC_VER )
 #  pragma warning( disable : 4101 )   // 'name': unreference local variable
-#elif defined( __clang__ )
+#endif
+#if defined( __clang__ )
 #  pragma clang diagnostic ignored "-Wunused-variable"
 #elif defined( __GNUC__ )
 #  pragma GCC diagnostic ignored "-Wunused-variable"

vulkan/vulkan_hash.hpp

@@ -94,15 +94,6 @@ namespace std
     }
   };
 
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::Event>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
-    }
-  };
-
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
   {
@@ -121,15 +112,6 @@ namespace std
     }
   };
 
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::BufferView>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
-    }
-  };
-
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::Image>
   {
@@ -148,6 +130,42 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::Event>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) );
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::BufferView>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) );
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
   {
@@ -238,35 +256,8 @@ namespace std
     }
   };
 
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) );
-    }
-  };
-
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) );
-    }
-  };
-
   //=== VK_VERSION_1_1 ===
 
-  template <>
-  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
-  {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
-    {
-      return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
-    }
-  };
-
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
   {
@@ -276,6 +267,15 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
+    {
+      return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) );
+    }
+  };
+
   //=== VK_VERSION_1_3 ===
 
   template <>
@@ -1385,6 +1385,18 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT const & beginCustomResolveInfoEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, beginCustomResolveInfoEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, beginCustomResolveInfoEXT.pNext );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV>
   {
@@ -3424,6 +3436,23 @@ namespace std
   };
 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT const & customResolveCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.customResolve );
+      VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.colorAttachmentCount );
+      VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.pColorAttachmentFormats );
+      VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.depthAttachmentFormat );
+      VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.stencilAttachmentFormat );
+      return seed;
+    }
+  };
+
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR>
@@ -3442,6 +3471,37 @@ namespace std
   };
 #  endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM const & physicalDeviceDataGraphOperationSupportARM ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.operationType );
+      for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; ++i )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.name[i] );
+      }
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.version );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM const & dataGraphPipelineBuiltinModelCreateInfoQCOM ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pOperation );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM>
   {
@@ -3858,6 +3918,35 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT const & decompressMemoryRegionEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.srcAddress );
+      VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.dstAddress );
+      VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.compressedSize );
+      VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.decompressedSize );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT const & decompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.decompressionMethod );
+      VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.regionCount );
+      VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pRegions );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV>
   {
@@ -5803,6 +5892,21 @@ namespace std
   };
 #  endif /*VK_USE_PLATFORM_ANDROID_KHR*/
 
+#  if defined( VK_USE_PLATFORM_OHOS )
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatOHOS>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatOHOS const & externalFormatOHOS ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.externalFormat );
+      return seed;
+    }
+  };
+#  endif /*VK_USE_PLATFORM_OHOS*/
+
 #  if defined( VK_USE_PLATFORM_SCREEN_QNX )
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatQNX>
@@ -7431,6 +7535,21 @@ namespace std
   };
 #  endif /*VK_USE_PLATFORM_METAL_EXT*/
 
+#  if defined( VK_USE_PLATFORM_OHOS )
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS const & importNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.buffer );
+      return seed;
+    }
+  };
+#  endif /*VK_USE_PLATFORM_OHOS*/
+
 #  if defined( VK_USE_PLATFORM_SCREEN_QNX )
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX>
@@ -8020,6 +8139,21 @@ namespace std
   };
 #  endif /*VK_USE_PLATFORM_METAL_EXT*/
 
+#  if defined( VK_USE_PLATFORM_OHOS )
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS const & memoryGetNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.memory );
+      return seed;
+    }
+  };
+#  endif /*VK_USE_PLATFORM_OHOS*/
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
   {
@@ -8428,6 +8562,74 @@ namespace std
     }
   };
 
+#  if defined( VK_USE_PLATFORM_OHOS )
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS const & nativeBufferFormatPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.format );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.externalFormat );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.formatFeatures );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.samplerYcbcrConversionComponents );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrModel );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrRange );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedXChromaOffset );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYChromaOffset );
+      return seed;
+    }
+  };
+#  endif /*VK_USE_PLATFORM_OHOS*/
+
+#  if defined( VK_USE_PLATFORM_OHOS )
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::NativeBufferOHOS>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferOHOS const & nativeBufferOHOS ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferOHOS.handle );
+      return seed;
+    }
+  };
+#  endif /*VK_USE_PLATFORM_OHOS*/
+
+#  if defined( VK_USE_PLATFORM_OHOS )
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS const & nativeBufferPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.allocationSize );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.memoryTypeBits );
+      return seed;
+    }
+  };
+#  endif /*VK_USE_PLATFORM_OHOS*/
+
+#  if defined( VK_USE_PLATFORM_OHOS )
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS const & nativeBufferUsageOHOS ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.OHOSNativeBufferUsage );
+      return seed;
+    }
+  };
+#  endif /*VK_USE_PLATFORM_OHOS*/
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT>
   {
@@ -8654,6 +8856,36 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterARM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterARM const & performanceCounterARM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.counterID );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM const & performanceCounterDescriptionARM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.flags );
+      for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.name[i] );
+      }
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>
   {
@@ -9482,6 +9714,20 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT const & physicalDeviceCustomResolveFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.customResolve );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM>
   {
@@ -9500,18 +9746,15 @@ namespace std
   };
 
   template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>
   {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM const & physicalDeviceDataGraphOperationSupportARM ) const
-      VULKAN_HPP_NOEXCEPT
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM const & physicalDeviceDataGraphModelFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT
     {
       std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.operationType );
-      for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; ++i )
-      {
-        VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.name[i] );
-      }
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.version );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.dataGraphModel );
       return seed;
     }
   };
@@ -11526,6 +11769,36 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR const & physicalDeviceMaintenance10FeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.maintenance10 );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR const & physicalDeviceMaintenance10PropertiesKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.rgba4OpaqueBlackSwizzled );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatAppliesTransferFunction );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatSupportsTransferFunctionControl );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
   {
@@ -11755,30 +12028,30 @@ namespace std
   };
 
   template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT>
   {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV const & physicalDeviceMemoryDecompressionFeaturesNV ) const
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT const & physicalDeviceMemoryDecompressionFeaturesEXT ) const
       VULKAN_HPP_NOEXCEPT
     {
       std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesNV.memoryDecompression );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.memoryDecompression );
       return seed;
     }
   };
 
   template <>
-  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT>
   {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV const & physicalDeviceMemoryDecompressionPropertiesNV ) const
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT const & physicalDeviceMemoryDecompressionPropertiesEXT ) const
       VULKAN_HPP_NOEXCEPT
     {
       std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.decompressionMethods );
-      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesNV.maxDecompressionIndirectCount );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.decompressionMethods );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.maxDecompressionIndirectCount );
       return seed;
     }
   };
@@ -12258,6 +12531,38 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM const &
+                              physicalDevicePerformanceCountersByRegionFeaturesARM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.performanceCountersByRegion );
+      return seed;
+    }
+  };
+
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM const &
+                              physicalDevicePerformanceCountersByRegionPropertiesARM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.maxPerRegionPerformanceCounters );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.performanceCounterRegionSize );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.rowStrideAlignment );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.regionAlignment );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.identityTransformOrder );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR>
   {
@@ -12607,6 +12912,22 @@ namespace std
     }
   };
 
+#  if defined( VK_USE_PLATFORM_OHOS )
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentationPropertiesOHOS const & physicalDevicePresentationPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentationPropertiesOHOS.sharedImage );
+      return seed;
+    }
+  };
+#  endif /*VK_USE_PLATFORM_OHOS*/
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
   {
@@ -12795,6 +13116,20 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const &
+                              physicalDeviceRayTracingInvocationReorderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.rayTracingInvocationReorder );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV>
   {
@@ -12810,6 +13145,21 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const &
+                              physicalDeviceRayTracingInvocationReorderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.rayTracingInvocationReorderReorderingHint );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.maxShaderBindingTableRecordIndex );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV>
   {
@@ -13150,6 +13500,20 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT const & physicalDeviceShader64BitIndexingFeaturesEXT ) const
+      VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.shader64BitIndexing );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>
   {
@@ -13845,6 +14209,20 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const &
+                              physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.shaderUniformBufferUnsizedArray );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR>
   {
@@ -15145,6 +15523,25 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>
+  {
+    std::size_t
+      operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM const & pipelineCacheHeaderVersionDataGraphQCOM ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerSize );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerVersion );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheType );
+      VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheVersion );
+      for ( size_t i = 0; i < VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM; ++i )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.toolchainVersion[i] );
+      }
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
   {
@@ -16722,6 +17119,24 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM const & renderPassPerformanceCountersByRegionBeginInfoARM )
+      const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterAddressCount );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterAddresses );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.serializeRegions );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterIndexCount );
+      VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterIndices );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>
   {
@@ -16882,6 +17297,19 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR const & renderingAttachmentFlagsInfoKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.flags );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo>
   {
@@ -16897,13 +17325,13 @@ namespace std
   };
 
   template <>
-  struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT>
+  struct hash<VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR>
   {
-    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT const & renderingEndInfoEXT ) const VULKAN_HPP_NOEXCEPT
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR const & renderingEndInfoKHR ) const VULKAN_HPP_NOEXCEPT
     {
       std::size_t seed = 0;
-      VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.sType );
-      VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoEXT.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.pNext );
       return seed;
     }
   };
@@ -16993,6 +17421,21 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR const & resolveImageModeInfoKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.flags );
+      VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.resolveMode );
+      VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.stencilResolveMode );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM>
   {
@@ -17989,6 +18432,21 @@ namespace std
     }
   };
 
+#  if defined( VK_USE_PLATFORM_OHOS )
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainImageCreateInfoOHOS const & swapchainImageCreateInfoOHOS ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, swapchainImageCreateInfoOHOS.usage );
+      return seed;
+    }
+  };
+#  endif /*VK_USE_PLATFORM_OHOS*/
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV>
   {

vulkan/vulkan_hpp_macros.hpp

@@ -35,6 +35,18 @@
 #  include <ciso646>
 #endif
 
+#define VULKAN_HPP_STRINGIFY2( text ) #text
+#define VULKAN_HPP_STRINGIFY( text )  VULKAN_HPP_STRINGIFY2( text )
+#define VULKAN_HPP_NAMESPACE_STRING   VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
+
+#if defined( __clang__ ) || defined( __GNUC__ ) || defined( __GNUG__ )
+#  define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( GCC warning text ) )
+#elif defined( _MSC_VER )
+#  define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LINE__ ) "): warning: " text ) ) )
+#else
+#  define VULKAN_HPP_COMPILE_WARNING( text )
+#endif
+
 #if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
 #  if !defined( VULKAN_HPP_NO_SMART_HANDLE )
 #    define VULKAN_HPP_NO_SMART_HANDLE
@@ -87,8 +99,8 @@
 #  define VULKAN_HPP_SUPPORT_SPAN
 #endif
 
-#if !defined( VULKAN_HPP_STD_MODULE ) && defined( VULKAN_HPP_CXX_MODULE )
-#  define VULKAN_HPP_STD_MODULE std.compat
+#if defined( VULKAN_HPP_CXX_MODULE ) && !( defined( __cpp_modules ) && defined( __cpp_lib_modules ) )
+VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ named modules and the standard library module." )
 #endif
 
 #ifndef VK_USE_64_BIT_PTR_DEFINES
@@ -225,10 +237,6 @@
 #  define VULKAN_HPP_NAMESPACE vk
 #endif
 
-#define VULKAN_HPP_STRINGIFY2( text ) #text
-#define VULKAN_HPP_STRINGIFY( text )  VULKAN_HPP_STRINGIFY2( text )
-#define VULKAN_HPP_NAMESPACE_STRING   VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
-
 #if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
 #  if defined( VK_NO_PROTOTYPES )
 #    define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
@@ -307,16 +315,11 @@ namespace VULKAN_HPP_NAMESPACE
 #endif
 
 #if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
-#  define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
-#  define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
-#  define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
 #  define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment )
 #else
-#  define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT         = {}
-#  define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
-#  define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT       = VULKAN_HPP_DEFAULT_DISPATCHER
 #  define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) = assignment
 #endif
+#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT VULKAN_HPP_DEFAULT_ASSIGNMENT( VULKAN_HPP_DEFAULT_DISPATCHER )
 
 #if !defined( VULKAN_HPP_RAII_NAMESPACE )
 #  define VULKAN_HPP_RAII_NAMESPACE        raii

vulkan/vulkan_shared.hpp

@@ -321,13 +321,12 @@ namespace VULKAN_HPP_NAMESPACE
 #    pragma clang diagnostic ignored "-Wcast-function-type"
 #  endif
 
-    template <typename HandleType>
+    template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     class ObjectDestroyShared
     {
     public:
       using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
 
-      template <class Dispatcher>
       using DestroyFunctionPointerType =
         typename std::conditional<HasDestructor<HandleType>::value,
                                   void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
@@ -335,10 +334,9 @@ namespace VULKAN_HPP_NAMESPACE
 
       using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
 
-      template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-      ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
                            const Dispatcher & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &SelectorType::destroy ) ) )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &SelectorType::destroy ) ) )
         , m_dispatch( &dispatch )
         , m_allocationCallbacks( allocationCallbacks )
       {
@@ -360,24 +358,22 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy             = nullptr;
-      const detail::DispatchLoaderBase *                     m_dispatch            = nullptr;
+      DestroyFunctionPointerType          m_destroy             = nullptr;
+      const Dispatcher *                  m_dispatch            = nullptr;
       Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
     };
 
-    template <typename HandleType>
+    template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     class ObjectFreeShared
     {
     public:
       using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
 
-      template <class Dispatcher>
       using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
 
-      template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-      ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+      ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
                         const Dispatcher & dispatch                             VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::free ) ) )
         , m_dispatch( &dispatch )
         , m_allocationCallbacks( allocationCallbacks )
       {
@@ -391,24 +387,21 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy             = nullptr;
-      const detail::DispatchLoaderBase *                     m_dispatch            = nullptr;
+      DestroyFunctionPointerType          m_destroy             = nullptr;
+      const Dispatcher *                  m_dispatch            = nullptr;
       Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
     };
 
-    template <typename HandleType>
+    template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     class ObjectReleaseShared
     {
     public:
       using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
 
-      template <class Dispatcher>
       using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
 
-      template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
       ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::release ) ) )
-        , m_dispatch( &dispatch )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::release ) ) ), m_dispatch( &dispatch )
       {
       }
 
@@ -420,11 +413,11 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy  = nullptr;
-      const detail::DispatchLoaderBase *                     m_dispatch = nullptr;
+      DestroyFunctionPointerType m_destroy  = nullptr;
+      const Dispatcher *         m_dispatch = nullptr;
     };
 
-    template <typename HandleType, typename PoolType>
+    template <typename HandleType, typename PoolType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     class PoolFreeShared
     {
     public:
@@ -432,17 +425,14 @@ namespace VULKAN_HPP_NAMESPACE
 
       using PoolTypeExport = PoolType;
 
-      template <class Dispatcher>
       using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
 
-      template <class Dispatcher>
-      using DestroyFunctionPointerType = ReturnType<Dispatcher> ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
+      using DestroyFunctionPointerType = ReturnType ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
 
       PoolFreeShared() = default;
 
-      template <class Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
       PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
-        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType<Dispatcher>>( &DestructorType::free ) ) )
+        : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::free ) ) )
         , m_dispatch( &dispatch )
         , m_pool( std::move( pool ) )
       {
@@ -456,8 +446,8 @@ namespace VULKAN_HPP_NAMESPACE
       }
 
     private:
-      DestroyFunctionPointerType<detail::DispatchLoaderBase> m_destroy  = nullptr;
-      const detail::DispatchLoaderBase *                     m_dispatch = nullptr;
+      DestroyFunctionPointerType m_destroy  = nullptr;
+      const Dispatcher *         m_dispatch = nullptr;
       SharedHandle<PoolType>     m_pool{};
     };
 
@@ -523,16 +513,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   using SharedSemaphore = SharedHandle<Semaphore>;
 
-  template <>
-  class SharedHandleTraits<Event>
-  {
-  public:
-    using DestructorType = Device;
-    using deleter        = detail::ObjectDestroyShared<Event>;
-  };
-
-  using SharedEvent = SharedHandle<Event>;
-
   template <>
   class SharedHandleTraits<QueryPool>
   {
@@ -553,16 +533,6 @@ namespace VULKAN_HPP_NAMESPACE
 
   using SharedBuffer = SharedHandle<Buffer>;
 
-  template <>
-  class SharedHandleTraits<BufferView>
-  {
-  public:
-    using DestructorType = Device;
-    using deleter        = detail::ObjectDestroyShared<BufferView>;
-  };
-
-  using SharedBufferView = SharedHandle<BufferView>;
-
   template <>
   class SharedHandleTraits<Image>
   {
@@ -583,6 +553,46 @@ namespace VULKAN_HPP_NAMESPACE
 
   using SharedImageView = SharedHandle<ImageView>;
 
+  template <>
+  class SharedHandleTraits<CommandPool>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::ObjectDestroyShared<CommandPool>;
+  };
+
+  using SharedCommandPool = SharedHandle<CommandPool>;
+
+  template <>
+  class SharedHandleTraits<CommandBuffer>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::PoolFreeShared<CommandBuffer, CommandPool>;
+  };
+
+  using SharedCommandBuffer = SharedHandle<CommandBuffer>;
+
+  template <>
+  class SharedHandleTraits<Event>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::ObjectDestroyShared<Event>;
+  };
+
+  using SharedEvent = SharedHandle<Event>;
+
+  template <>
+  class SharedHandleTraits<BufferView>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::ObjectDestroyShared<BufferView>;
+  };
+
+  using SharedBufferView = SharedHandle<BufferView>;
+
   template <>
   class SharedHandleTraits<ShaderModule>
   {
@@ -683,38 +693,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   using SharedRenderPass = SharedHandle<RenderPass>;
 
-  template <>
-  class SharedHandleTraits<CommandPool>
-  {
-  public:
-    using DestructorType = Device;
-    using deleter        = detail::ObjectDestroyShared<CommandPool>;
-  };
-
-  using SharedCommandPool = SharedHandle<CommandPool>;
-
-  template <>
-  class SharedHandleTraits<CommandBuffer>
-  {
-  public:
-    using DestructorType = Device;
-    using deleter        = detail::PoolFreeShared<CommandBuffer, CommandPool>;
-  };
-
-  using SharedCommandBuffer = SharedHandle<CommandBuffer>;
-
   //=== VK_VERSION_1_1 ===
-  template <>
-  class SharedHandleTraits<SamplerYcbcrConversion>
-  {
-  public:
-    using DestructorType = Device;
-    using deleter        = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
-  };
-
-  using SharedSamplerYcbcrConversion    = SharedHandle<SamplerYcbcrConversion>;
-  using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>;
-
   template <>
   class SharedHandleTraits<DescriptorUpdateTemplate>
   {
@@ -726,6 +705,17 @@ namespace VULKAN_HPP_NAMESPACE
   using SharedDescriptorUpdateTemplate    = SharedHandle<DescriptorUpdateTemplate>;
   using SharedDescriptorUpdateTemplateKHR = SharedHandle<DescriptorUpdateTemplate>;
 
+  template <>
+  class SharedHandleTraits<SamplerYcbcrConversion>
+  {
+  public:
+    using DestructorType = Device;
+    using deleter        = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
+  };
+
+  using SharedSamplerYcbcrConversion    = SharedHandle<SamplerYcbcrConversion>;
+  using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>;
+
   //=== VK_VERSION_1_3 ===
   template <>
   class SharedHandleTraits<PrivateDataSlot>