Add some explicit static_cast to the SharedHandles sample and the UniqueHandleDefaultArguments test. (#2370)

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

.github/workflows/ci-macos.yml

@@ -72,7 +72,6 @@ jobs:
           -D VULKAN_HPP_RUN_GENERATOR=OFF              \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
           -D VULKAN_HPP_TESTS_BUILD=OFF                \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF       \
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
@@ -86,7 +85,6 @@ jobs:
           -D VULKAN_HPP_RUN_GENERATOR=ON               \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
           -D VULKAN_HPP_TESTS_BUILD=OFF                \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF       \
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
@@ -108,11 +106,9 @@ jobs:
               -D VULKAN_HPP_RUN_GENERATOR=OFF                 \
               -D VULKAN_HPP_SAMPLES_BUILD=ON                  \
               -D VULKAN_HPP_TESTS_BUILD=ON                    \
-              -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF          \
               -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON        \
               -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON    \
               -D VULKAN_HPP_PRECOMPILE=OFF                    \
-              -D VULKAN_HPP_NO_STD_MODULE=ON                  \
               -D CMAKE_CXX_COMPILER=${{matrix.compiler}}      \
               -D CMAKE_CXX_STANDARD=$CXX_STANDARD             \
               -D CMAKE_BUILD_TYPE=$BUILD_TYPE

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

@@ -74,7 +74,6 @@ jobs:
           -D VULKAN_HPP_RUN_GENERATOR=OFF              \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
           -D VULKAN_HPP_TESTS_BUILD=OFF                \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF       \
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
@@ -88,7 +87,6 @@ jobs:
           -D VULKAN_HPP_RUN_GENERATOR=ON               \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
           -D VULKAN_HPP_TESTS_BUILD=OFF                \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF       \
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
@@ -116,11 +114,9 @@ jobs:
               -D VULKAN_HPP_RUN_GENERATOR=OFF              \
               -D VULKAN_HPP_SAMPLES_BUILD=ON               \
               -D VULKAN_HPP_TESTS_BUILD=ON                 \
-              -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF       \
               -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
               -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
               -D VULKAN_HPP_PRECOMPILE=OFF                 \
-              -D VULKAN_HPP_NO_STD_MODULE=ON               \
               -D CMAKE_CXX_COMPILER=${{matrix.compiler}}   \
               -D CMAKE_CXX_STANDARD=$CXX_STANDARD          \
               -D CMAKE_BUILD_TYPE=$BUILD_TYPE

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

@@ -74,7 +74,6 @@ jobs:
           -D VULKAN_HPP_RUN_GENERATOR=OFF              \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
           -D VULKAN_HPP_TESTS_BUILD=OFF                \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF       \
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
@@ -88,7 +87,6 @@ jobs:
           -D VULKAN_HPP_RUN_GENERATOR=ON               \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
           -D VULKAN_HPP_TESTS_BUILD=OFF                \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF       \
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
@@ -121,11 +119,9 @@ jobs:
               -D VULKAN_HPP_RUN_GENERATOR=OFF                 \
               -D VULKAN_HPP_SAMPLES_BUILD=ON                  \
               -D VULKAN_HPP_TESTS_BUILD=ON                    \
-              -D VULKAN_HPP_ENABLE_CPP20_MODULES=$CXX_MODULES \
               -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON        \
               -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON    \
               -D VULKAN_HPP_PRECOMPILE=OFF                    \
-              -D VULKAN_HPP_NO_STD_MODULE=ON                  \
               -D CMAKE_CXX_COMPILER=${{matrix.compiler}}      \
               -D CMAKE_CXX_STANDARD=$CXX_STANDARD             \
               -D CMAKE_BUILD_TYPE=$BUILD_TYPE

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

@@ -85,7 +85,6 @@ jobs:
           -D VULKAN_HPP_RUN_GENERATOR=OFF                           \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF                           \
           -D VULKAN_HPP_TESTS_BUILD=OFF                             \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF                    \
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON                  \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON              \
           -D VULKAN_HPP_PRECOMPILE=OFF                              \
@@ -99,7 +98,6 @@ jobs:
           -D VULKAN_HPP_RUN_GENERATOR=ON                            \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF                           \
           -D VULKAN_HPP_TESTS_BUILD=OFF                             \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=OFF                    \
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON                  \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON              \
           -D VULKAN_HPP_PRECOMPILE=OFF                              \
@@ -127,11 +125,9 @@ jobs:
               -D VULKAN_HPP_RUN_GENERATOR=OFF                         \
               -D VULKAN_HPP_SAMPLES_BUILD=ON                          \
               -D VULKAN_HPP_TESTS_BUILD=ON                            \
-              -D VULKAN_HPP_ENABLE_CPP20_MODULES=$CXX_MODULES         \
               -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON                \
               -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON            \
               -D VULKAN_HPP_PRECOMPILE=OFF                            \
-              -D VULKAN_HPP_NO_STD_MODULE=ON                          \
               -D CMAKE_CXX_COMPILER=clang++-${{matrix.clang_version}} \
               -D CMAKE_CXX_STANDARD=$CXX_STANDARD                     \
               -D CMAKE_BUILD_TYPE=$BUILD_TYPE

.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,7 +31,8 @@ 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        \
@@ -41,8 +42,8 @@ jobs:
     #     cmake --install build
 
     #     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        \
@@ -52,7 +53,9 @@ jobs:
     #     cmake --install build
 
     #     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              \
@@ -64,57 +67,52 @@ 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              \
           -D VULKAN_HPP_TESTS_BUILD=OFF                \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=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                     \
-          -D CMAKE_BUILD_TYPE=Debug
+          -D CMAKE_BUILD_TYPE=Debug                    \
+          -D CMAKE_CXX_COMPILER=clang-cl               \
+          -D CMAKE_CXX_STANDARD=20
         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              \
           -D VULKAN_HPP_TESTS_BUILD=OFF                \
-          -D VULKAN_HPP_ENABLE_CPP20_MODULES=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                     \
-          -D CMAKE_BUILD_TYPE=Release
+          -D CMAKE_BUILD_TYPE=Release                  \
+          -D CMAKE_CXX_COMPILER=clang-cl               \
+          -D CMAKE_CXX_STANDARD=20
         cmake --build build --parallel --clean-first
 
     - name: Build samples and tests
       run: |
         for CXX_STANDARD in 11 14 17 20 23; do
           for BUILD_TYPE in Debug Release; do
-            CXX_MODULES=ON
-            if [ ${{matrix.compiler}} == "windows-2019" ] || [ $CXX_STANDARD -lt 20 ]; then
-              CXX_MODULES=OFF
-            fi
-
             echo "================================================================================="
             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_GENERATOR_BUILD=OFF               \
               -D VULKAN_HPP_RUN_GENERATOR=OFF                 \
               -D VULKAN_HPP_SAMPLES_BUILD=ON                  \
               -D VULKAN_HPP_TESTS_BUILD=ON                    \
-              -D VULKAN_HPP_ENABLE_CPP20_MODULES=$CXX_MODULES \
               -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON        \
               -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON    \
               -D VULKAN_HPP_PRECOMPILE=OFF                    \
-              -D VULKAN_HPP_NO_STD_MODULE=ON                  \
-              -D CMAKE_CXX_STANDARD=$CXX_STANDARD             \
-              -D CMAKE_BUILD_TYPE=$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
             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

@@ -24,14 +24,10 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-cmake_minimum_required( VERSION 3.12 )
+cmake_minimum_required( VERSION 3.22 )
+include( CMakeDependentOption )
 project( VulkanHppGenerator LANGUAGES CXX )
 
-if( CMAKE_VERSION VERSION_LESS "3.21" )
-    # https://cmake.org/cmake/help/latest/variable/PROJECT_IS_TOP_LEVEL.html
-    string( COMPARE EQUAL ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR} PROJECT_IS_TOP_LEVEL )
-endif()
-
 if ( NOT DEFINED CMAKE_CXX_STANDARD AND PROJECT_IS_TOP_LEVEL )
 	set( CMAKE_CXX_STANDARD 11 )
 endif()
@@ -43,12 +39,13 @@ option( VULKAN_HPP_GENERATOR_BUILD "Build the HPP generator" ${PROJECT_IS_TOP_LE
 option( VULKAN_HPP_SAMPLES_BUILD "Build samples" OFF )
 option( VULKAN_HPP_TESTS_BUILD "Build tests" OFF )
 option( VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP "Build with local Vulkan headers" ON )
-option( VULKAN_HPP_ENABLE_CPP20_MODULES "Build Vulkan-Hpp as C++20 module; requires minimum CMake version 3.28" OFF )
-option( VULKAN_HPP_ENABLE_STD_MODULE "Build Vulkan-Hpp with import std; requires minimum CMake version 3.30" OFF )
+cmake_dependent_option( VULKAN_HPP_BUILD_CXX_MODULE "Build and test the C++ named module." ON [[ TARGET __CMAKE::CXX23 ]] OFF)
+
 # options for vulkan hpp compile definitions (see https://github.com/KhronosGroup/Vulkan-Hpp/tree/main?tab=readme-ov-file#configuration-options for details)
 option( VULKAN_HPP_DISABLE_ENHANCED_MODE "Disable all enhanced functionality apart from scoped enums, bitmasks, default initialization and vk::StructureChain" OFF )
 option( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC "Select the dynamic (ON) or static (OFF) dispatch loader (defaults to VK_NO_PROTOTYPES)" ${VK_NO_PROTOTYPES} )
 option( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC "Change the m_mask access modifier in vk::Flags to public" OFF )
+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_EXCEPTIONS "Do not throw exceptions when vulkan functions return an error code" OFF )
@@ -56,7 +53,6 @@ option( VULKAN_HPP_NO_NODISCARD_WARNINGS "Remove C++17 [[nodiscard]] from functi
 option( VULKAN_HPP_NO_SETTERS "Remove setters for structs and unions" OFF )
 option( VULKAN_HPP_NO_SMART_HANDLE "Remove the vk::UniqueHandle helper class" OFF )
 option( VULKAN_HPP_NO_SPACESHIP_OPERATOR "Remove the C++20 <=> (spaceship) operator" OFF )
-option( VULKAN_HPP_NO_STD_MODULE "Prevent the automatic use of import std in the C++20 module when compiling with C++23" OFF )
 option( VULKAN_HPP_NO_TO_STRING "Remove inclusion of vulkan_to_string.hpp from vulkan.hpp" OFF )
 option( VULKAN_HPP_NO_WIN32_PROTOTYPES "Remove HINSTANCE, LoadLibraryA and other symbols, which are declared if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL is enabled on Win32" OFF )
 option( VULKAN_HPP_RAII_NO_EXCEPTIONS "Do not throw exceptions when vulkan functions from vk::raii return an error code." OFF )
@@ -249,6 +245,9 @@ endif()
 if( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
 	target_compile_definitions(VulkanHpp INTERFACE "VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC" )
 endif()
+if( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS )
+	target_compile_definitions(VulkanHpp INTERFACE "VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS" )
+endif()
 if( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST )
 	target_compile_definitions(VulkanHpp INTERFACE "VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST" )
 endif()
@@ -279,9 +278,6 @@ endif()
 if( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
 	target_compile_definitions(VulkanHpp INTERFACE "VULKAN_HPP_NO_SPACESHIP_OPERATOR" )
 endif()
-if( VULKAN_HPP_NO_STD_MODULE )
-	target_compile_definitions(VulkanHpp INTERFACE "VULKAN_HPP_NO_STD_MODULE" )
-endif()
 
 function( vulkan_hpp__setup_vulkan_include )
 	set( options )
@@ -320,17 +316,8 @@ function( vulkan_hpp__setup_vulkan_module )
 		add_library(${TARGET_ALIAS_NAME} ALIAS ${TARGET_NAME})
 	endforeach()
 
-	# Clang 16's module support can be broken with extensions enabled
-	if ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "16.0" )
-		set_target_properties( ${TARGET_NAME} PROPERTIES CXX_EXTENSIONS OFF )
-	endif()
-
-	if ( VULKAN_HPP_ENABLE_STD_MODULE )
 	target_compile_features( ${TARGET_NAME} PUBLIC cxx_std_23 )
 	set_target_properties( ${TARGET_NAME} PROPERTIES CXX_MODULE_STD ON )
-	else()
-		target_compile_features( ${TARGET_NAME} PUBLIC cxx_std_20 )
-	endif()
 
 	if ( NOT TARGET_FILE_SET )
 		message( FATAL_ERROR "FILE_SET must be defined in vulkan_hpp__setup_module" )
@@ -350,14 +337,8 @@ function( vulkan_hpp__setup_vulkan_module )
 endfunction()
 
 # Build Vulkan-Hpp as a module
-if( VULKAN_HPP_ENABLE_CPP20_MODULES )
-	if ( VULKAN_HPP_ENABLE_STD_MODULE AND CMAKE_VERSION VERSION_LESS "3.30" )
-		message( FATAL_ERROR "Vulkan-Hpp: C++20 modules with import std require CMake 3.30 or later" )
-	elseif ( CMAKE_VERSION VERSION_LESS "3.28" )
-		message( FATAL_ERROR "Vulkan-Hpp: C++20 modules require CMake 3.28 or later" )
-	endif()
-
-	# create targets providing VulkanHpp and VulkanVideoHpp as C++20 modules
+if( VULKAN_HPP_BUILD_CXX_MODULE )
+	# create targets providing VulkanHpp and VulkanVideoHpp as C++ named modules
 	vulkan_hpp__setup_vulkan_module( NAME VulkanHppModule
 		FILE_SET_NAME vulkan_module_file
 		FILE_SET vulkan/vulkan.cppm

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();

README.md

@@ -64,6 +64,7 @@ The goal of the Vulkan-Hpp is to provide header only C++ bindings for the Vulkan
 	- [VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL](#enable_dynamic_loader_tool)
 	- [VULKAN_HPP_EXPECTED](#expected)
 	- [VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC](#flags_mask_type_as_public)
+	- [VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS](#handle_error_out_of_date_as_success)
 	- [VULKAN_HPP_HANDLES_MOVE_EXCHANGE](#handles_move_exchange)
 	- [VULKAN_HPP_HASH_COMBINE](#hash_combine)
 	- [VULKAN_HPP_INLINE](#inline)
@@ -1014,6 +1015,10 @@ When this is not externally defined and `VULKAN_HPP_CPP_VERSION` is at least `23
 
 By default, the member `m_mask` of the `Flags` class template is private. This is to prevent accidentally setting a `Flags` with some inappropriate value. But it also prevents using a `Flags`, or a structure holding a `Flags`, to be used as a non-type template parameter. If you really need that functionality, and accept the reduced security, you can use this define to change the access specifier for `m_mask` from private to public, which allows using a `Flags` as a non-type template parameter.
 
+#### VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS <a id='handle_error_out_of_date_as_success'>
+
+By default, `VK_ERROR_OUT_OF_DATE_KHR` is an error code. To prevent throwing an exception or, in case exceptions are turned off via `VULKAN_HPP_NO_EXCEPTIONS`, firing an assertion on this return value, you can define `VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS`. `VK_ERROR_OUT_OF_DATE_KHR` will then be handled like a success code.
+
 #### VULKAN_HPP_HANDLES_MOVE_EXCHANGE <a id='handles_move_exchange'>
 
 This define can be used to enable `m_handle = exchange( rhs.m_handle, {} )` in move constructors of Vulkan-Hpp handles, which default-initializes the `rhs` underlying value. By default Vulkan-Hpp handles behave like trivial types -- move constructors copying value.

Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 9a0f3099c8a9607a7c0f3127d8abfdc19a93e8c5
+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       = {};
@@ -309,6 +316,8 @@ private:
     std::vector<std::string>   api           = {};
     std::string                name          = {};
     std::string                number        = {};
+    bool                       isInternal    = false;
+    std::vector<std::string>   depends       = {};
     std::vector<DeprecateData> deprecateData = {};
     std::vector<RemoveData>    removeData    = {};
     std::vector<RequireData>   requireData   = {};
@@ -418,7 +427,7 @@ private:
     int                                               xmlLine = {};
   };
 
-  struct StructureData
+  struct StructData
   {
     std::map<std::string, int> aliases             = {};
     bool                       allowDuplicate      = {};
@@ -567,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,
@@ -588,25 +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::map<std::string, NameLine>::const_iterator findAlias( std::string const & name, std::map<std::string, NameLine> const & aliases ) const;
-  std::string                                     findBaseName( std::string aliasName, std::map<std::string, NameLine> const & aliases ) const;
-  std::vector<FeatureData>::const_iterator        findFeature( std::string const & name ) const;
-  std::vector<ParamData>::const_iterator          findParamIt( std::string const & name, std::vector<ParamData> const & paramData ) const;
-  std::vector<MemberData>::const_iterator         findStructMemberIt( std::string const & name, std::vector<MemberData> const & memberData ) const;
-  std::vector<MemberData>::const_iterator         findStructMemberItByType( std::string const & type, std::vector<MemberData> const & memberData ) const;
-  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,
@@ -637,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,
@@ -775,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;
@@ -1067,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;
@@ -1097,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;
@@ -1156,6 +1173,8 @@ private:
   bool isUnsupportedFeature( std::string const & name ) const;
   bool isVectorByStructure( std::string const & type ) const;
   void markExtendedStructs();
+  void mergeInternalFeatures();
+  void mergeInternalFeatures( std::vector<std::string> const & depends, FeatureData & feature, std::map<std::string, FeatureData> & internalFeatures );
   bool needsStructureChainResize( std::map<size_t, VectorParamData> const & vectorParams, std::vector<size_t> const & chainedReturnParams ) const;
   std::pair<bool, std::map<size_t, std::vector<size_t>>> needsVectorSizeCheck( std::vector<ParamData> const &            params,
                                                                                std::map<size_t, VectorParamData> const & vectorParams,
@@ -1254,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;
@@ -1266,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{ 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

@@ -1,13 +1,19 @@
 ${licenseHeader}
 
-// Note: This module is still in an experimental state.
-// Any feedback is welcome on https://github.com/KhronosGroup/Vulkan-Hpp/issues.
-
 module;
 
-#include <version>
-#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_NO_STD_MODULE )
-#  define VULKAN_HPP_ENABLE_STD_MODULE
+#define VULKAN_HPP_CXX_MODULE 1
+
+#include <vulkan/vulkan_hpp_macros.hpp>
+
+#if !defined( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING )
+#  define VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING \
+  "The Vulkan-Hpp C++ named module is experimental. " \
+  "It is subject to change without prior notice.\n" \
+  "To silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n\n" \
+  "For feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues"
+
+  VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING )
 #endif
 
 #include <vulkan/${api}.hpp>
@@ -18,9 +24,7 @@ module;
 #include <vulkan/${api}_shared.hpp>
 
 export module ${api}_hpp;
-#if defined( VULKAN_HPP_ENABLE_STD_MODULE )
-  export import VULKAN_HPP_STD_MODULE;
-#endif
+export import std;
 
 export namespace VULKAN_HPP_NAMESPACE
 {
@@ -48,8 +52,11 @@ export namespace std
 #endif
 }
 
-// This VkFlags type is used as part of a bitfield in some structure.
-// As it can't be mimicked by vk-data types, we need to export just that!!
-export using ::VkGeometryInstanceFlagsKHR;
+export
+{
+// This VkFlags type is used as part of a bitfield in some structures.
+// As it can't be mimicked by vk-data types, we need to export just that.
+using ::VkGeometryInstanceFlagsKHR;
 
 ${pfnCommands}
+}

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/EnumsHppTemplate.hpp

@@ -6,9 +6,7 @@ ${licenseHeader}
 // include-what-you-use: make sure, vulkan.hpp is used by code-completers
 // IWYU pragma: private, include "vulkan/vulkan.hpp"
 
-#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
-import VULKAN_HPP_STD_MODULE;
-#else
+#if !defined( VULKAN_HPP_CXX_MODULE )
 #  include <type_traits>    // for std::underlying_type
 #endif
 

snippets/ExtensionInspectionHppTemplate.hpp

@@ -3,9 +3,7 @@ ${licenseHeader}
 #ifndef VULKAN_EXTENSION_INSPECTION_HPP
 #define VULKAN_EXTENSION_INSPECTION_HPP
 
-#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
-import VULKAN_HPP_STD_MODULE;
-#else
+#if !defined( VULKAN_HPP_CXX_MODULE )
 #  include <map>
 #  include <set>
 #  include <string>
@@ -70,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_ENABLE_STD_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,14 +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/RAIIHppTemplate.hpp

@@ -3,7 +3,7 @@ ${licenseHeader}
 #define VULKAN_RAII_HPP
 
 #include <vulkan/${api}.hpp>
-#if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
+#if !defined( VULKAN_HPP_CXX_MODULE )
 #  include <memory>   // std::unique_ptr
 #  include <utility>  // std::forward
 #endif

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

@@ -5,7 +5,7 @@ ${licenseHeader}
 
 #include <vulkan/${api}.hpp>
 
-#if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
+#if !defined( VULKAN_HPP_CXX_MODULE )
 #include <atomic>  // std::atomic_size_t
 #endif
 
@@ -79,7 +79,7 @@ namespace VULKAN_HPP_NAMESPACE
   template <typename DestructorType, typename Deleter>
   struct SharedHeader
   {
-    SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
+    SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT
       : parent( std::move( parent ) )
       , deleter( std::move( deleter ) )
     {
@@ -92,7 +92,7 @@ namespace VULKAN_HPP_NAMESPACE
   template <typename Deleter>
   struct SharedHeader<NoDestructor, Deleter>
   {
-    SharedHeader( Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
+    SharedHeader( Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
 
     Deleter deleter;
   };
@@ -126,7 +126,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   public:
     std::atomic_size_t m_ref_cnt{ 1 };
-    HeaderType         m_header{};
+    HeaderType         m_header;
   };
 
   //=====================================================================================================================
@@ -277,7 +277,9 @@ namespace VULKAN_HPP_NAMESPACE
     SharedHandle() = default;
 
     template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value && !HasPoolType<T>::value>::type>
-    explicit SharedHandle( HandleType handle, SharedHandle<DestructorTypeOf<HandleType>> parent, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
+    explicit SharedHandle( HandleType                                 handle,
+                           SharedHandle<DestructorTypeOf<HandleType>> parent,
+                           DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
       : BaseType( handle, std::move( parent ), std::move( deleter ) )
     {
     }
@@ -294,7 +296,9 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
-    explicit SharedHandle( HandleType handle, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT : BaseType( handle, std::move( deleter ) )
+    explicit SharedHandle( HandleType  handle,
+                           DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
+      : BaseType( handle, std::move( deleter ) )
     {
     }
 
@@ -313,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,
@@ -327,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 )
       {
@@ -352,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 )
       {
@@ -383,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 )
       {
       }
@@ -412,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:
@@ -424,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 ) )
       {
@@ -448,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{};
     };
 
@@ -472,7 +467,8 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageHeader : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>
   {
     ImageHeader( SharedHandle<DestructorTypeOf<Image>>       parent,
-                 typename SharedHandleTraits<Image>::deleter deleter        = typename SharedHandleTraits<Image>::deleter(),
+                 typename SharedHandleTraits<Image>::deleter deleter 
+                   VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<Image>::deleter() ),
                  SwapchainOwns                               swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
       : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>( std::move( parent ), std::move( deleter ) )
       , swapchainOwned( swapchainOwned )
@@ -494,8 +490,8 @@ namespace VULKAN_HPP_NAMESPACE
 
     explicit SharedHandle( Image                                 handle,
                            SharedHandle<DestructorTypeOf<Image>> parent,
-                           SwapchainOwns                         swapchain_owned = SwapchainOwns::no,
-                           DeleterType                           deleter         = DeleterType() ) VULKAN_HPP_NOEXCEPT
+                           SwapchainOwns                         swapchain_owned VULKAN_HPP_DEFAULT_ASSIGNMENT( SwapchainOwns::no ),
+                           DeleterType                           deleter         VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
       : BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
     {
     }
@@ -514,16 +510,17 @@ namespace VULKAN_HPP_NAMESPACE
   {
     SwapchainHeader( SharedHandle<SurfaceKHR>                           surface,
                      SharedHandle<DestructorTypeOf<SwapchainKHR>>       parent,
-                     typename SharedHandleTraits<SwapchainKHR>::deleter deleter = typename SharedHandleTraits<SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
+                     typename SharedHandleTraits<SwapchainKHR>::deleter deleter 
+                        VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<SwapchainKHR>::deleter() ) ) VULKAN_HPP_NOEXCEPT
       : surface( std::move( surface ) )
       , parent( std::move( parent ) )
       , deleter( std::move( deleter ) )
     {
     }
 
-    SharedHandle<SurfaceKHR>                           surface{};
-    SharedHandle<DestructorTypeOf<SwapchainKHR>>       parent{};
-    typename SharedHandleTraits<SwapchainKHR>::deleter deleter{};
+    SharedHandle<SurfaceKHR>                           surface;
+    SharedHandle<DestructorTypeOf<SwapchainKHR>>       parent;
+    typename SharedHandleTraits<SwapchainKHR>::deleter deleter;
   };
 
   template <>
@@ -539,7 +536,7 @@ namespace VULKAN_HPP_NAMESPACE
     explicit SharedHandle( SwapchainKHR                                 handle,
                            SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
                            SharedHandle<SurfaceKHR>                     surface,
-                           DeleterType                                  deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
+                           DeleterType                                  deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
       : BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
     {
     }

snippets/StructsHppTemplate.hpp

@@ -6,8 +6,9 @@ ${licenseHeader}
 // include-what-you-use: make sure, vulkan.hpp is used by code-completers
 // IWYU pragma: private, include "vulkan/vulkan.hpp"
 
-#include <cstring>  // strcmp
-#include <cstdlib>  // free
+#if !defined( VULKAN_HPP_CXX_MODULE )
+#  include <cstring>  // strcmp
+#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/ToStringHppTemplate.hpp

@@ -2,7 +2,9 @@ ${licenseHeader}
 #ifndef VULKAN_TO_STRING_HPP
 #  define VULKAN_TO_STRING_HPP
 
-#include <vulkan/${api}.hpp>
+#if !defined( VULKAN_HPP_CXX_MODULE )
+#  include <vulkan/${api}.hpp>
+#endif
 
 // ignore warnings on using deprecated enum values in this header
 #if defined( __clang__ ) || defined( __GNUC__ )
@@ -13,10 +15,8 @@ ${licenseHeader}
 #  pragma warning( disable : 4996 )
 #endif
 
-#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
-import VULKAN_HPP_STD_MODULE;
-#else
-#  if __cpp_lib_format
+#if !defined( VULKAN_HPP_CXX_MODULE )
+#  if defined( __cpp_lib_format )
 #    include <format>   // std::format
 #  else
 #    include <sstream>  // std::stringstream

snippets/VideoCppmTemplate.hpp

@@ -7,10 +7,6 @@ module;
 
 #include <vulkan/vulkan_hpp_macros.hpp>
 
-#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
-#define VULKAN_HPP_ENABLE_STD_MODULE
-#endif
-
 #include <vulkan/vulkan_video.hpp>
 
 export module vulkan_video_hpp;

snippets/includes.hpp

@@ -1,11 +1,8 @@
-#include <vulkan/vulkan_hpp_macros.hpp>
-
-#if defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE )
-#  include <cassert>
-#  include <cstring>
-#  include <cstdlib>
-import VULKAN_HPP_STD_MODULE;
-#else
+#include <vulkan/${vulkan_h}>
+#if !defined( VULKAN_HPP_CXX_MODULE )
+// clang-format off
+#  include <vulkan/vulkan_hpp_macros.hpp>
+// clang-format on
 #  include <algorithm>
 #  include <array>  // ArrayWrapperND
 #  include <cassert>
@@ -28,8 +25,11 @@ import VULKAN_HPP_STD_MODULE;
 #  if defined( VULKAN_HPP_SUPPORT_SPAN )
 #    include <span>
 #  endif
+#else
+#  include <cassert>
+#  include <cstring>
+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"

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"

tests/CMakeLists.txt

@@ -41,6 +41,7 @@ add_subdirectory( FunctionCallsRAII )
 add_subdirectory( Handles )
 add_subdirectory( HandlesMoveExchange )
 add_subdirectory( Hash )
+add_subdirectory( NoDefaultDispatcher )
 add_subdirectory( NoExceptions )
 if( ( CMAKE_CXX_STANDARD GREATER_EQUAL 23 ) AND NOT ( ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" ) AND ( CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15.0 ) ) )
 	# This test is for C++23 only... but clang++13 and clang++14 seem to have a problem with it

tests/DesignatedInitializers/DesignatedInitializers.cpp

@@ -17,9 +17,10 @@
 
 #include <cstdint>
 #include <iostream>
+#include <vector>
 #ifdef VULKAN_HPP_USE_CXX_MODULE
 #  include <vulkan/vulkan_hpp_macros.hpp>
-  import vulkan_hpp;
+import vulkan_hpp;
 #else
 #  include <vulkan/vulkan.hpp>
 #endif
@@ -91,6 +92,15 @@ int main( int /*argc*/, char ** /*argv*/ )
 
   vk::ApplicationInfo ai5{ .pEngineName = engineName };
   vk::ApplicationInfo ai6{ .pApplicationName = appName, .apiVersion = vk::ApiVersion12 };
+
+  std::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;
+  std::vector<char const *>              extensions;
+  vk::DeviceCreateInfo                   info_device{
+                      .queueCreateInfoCount    = (uint32_t)queueCreateInfos.size(),
+                      .pQueueCreateInfos       = queueCreateInfos.data(),
+                      .enabledExtensionCount   = (uint32_t)extensions.size(),
+                      .ppEnabledExtensionNames = extensions.data(),
+  };
 #  endif
 #endif
 

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

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

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

@@ -15,13 +15,13 @@
 // VulkanHpp Samples : FormatTraits
 //                     Compile test on using format traits functions
 
+#include <cassert>
+#include <cstring>
+#include <iostream>
 #include <map>
 #include <set>
-#include <cstring>
-#include <cassert>
-#include <iostream>
 #ifdef VULKAN_HPP_USE_CXX_MODULE
-  import vulkan_hpp;
+import vulkan_hpp;
 #else
 #  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"
@@ -187,6 +188,407 @@ int main( int /*argc*/, char ** /*argv*/ )
     device.destroy();
   }
 
+  // Extension discovery commands
+  {
+    uint32_t   propertyCount;
+    vk::Result result = vk::enumerateInstanceExtensionProperties( nullptr, &propertyCount, nullptr );
+    if ( result == vk::Result::eSuccess )
+    {
+      std::vector<vk::ExtensionProperties> properties( propertyCount );
+      result = vk::enumerateInstanceExtensionProperties( nullptr, &propertyCount, properties.data() );
+    }
+  }
+  {
+    std::vector<vk::ExtensionProperties> properties = vk::enumerateInstanceExtensionProperties( nullptr );
+  }
+  {
+    using Allocator = std::allocator<vk::ExtensionProperties>;
+    Allocator                                       allocator;
+    std::vector<vk::ExtensionProperties, Allocator> properties = vk::enumerateInstanceExtensionProperties( nullptr, allocator );
+  }
+
+  {
+    vk::PhysicalDevice physicalDevice;
+    uint32_t           propertyCount;
+    vk::Result         result = physicalDevice.enumerateDeviceExtensionProperties( nullptr, &propertyCount, nullptr );
+    if ( result == vk::Result::eSuccess )
+    {
+      std::vector<vk::ExtensionProperties> properties( propertyCount );
+      result = physicalDevice.enumerateDeviceExtensionProperties( nullptr, &propertyCount, properties.data() );
+    }
+  }
+  {
+    vk::PhysicalDevice                   physicalDevice;
+    std::vector<vk::ExtensionProperties> properties = physicalDevice.enumerateDeviceExtensionProperties( nullptr );
+  }
+  {
+    vk::PhysicalDevice physicalDevice;
+    using Allocator = std::allocator<vk::ExtensionProperties>;
+    Allocator                                       allocator;
+    std::vector<vk::ExtensionProperties, Allocator> properties = physicalDevice.enumerateDeviceExtensionProperties( nullptr, allocator );
+  }
+
+  // Layer discovery commands
+  {
+    uint32_t   propertyCount;
+    vk::Result result = vk::enumerateInstanceLayerProperties( &propertyCount, nullptr );
+    if ( result == vk::Result::eSuccess )
+    {
+      std::vector<vk::LayerProperties> properties( propertyCount );
+      result = vk::enumerateInstanceLayerProperties( &propertyCount, properties.data() );
+    }
+  }
+  {
+    std::vector<vk::LayerProperties> properties = vk::enumerateInstanceLayerProperties();
+  }
+  {
+    using Allocator = std::allocator<vk::LayerProperties>;
+    Allocator                                   allocator;
+    std::vector<vk::LayerProperties, Allocator> properties = vk::enumerateInstanceLayerProperties( allocator );
+  }
+
+  {
+    vk::PhysicalDevice physicalDevice;
+    uint32_t           propertyCount;
+    vk::Result         result = physicalDevice.enumerateDeviceLayerProperties( &propertyCount, nullptr );
+    if ( result == vk::Result::eSuccess )
+    {
+      std::vector<vk::LayerProperties> properties( propertyCount );
+      result = physicalDevice.enumerateDeviceLayerProperties( &propertyCount, properties.data() );
+    }
+  }
+  {
+    vk::PhysicalDevice               physicalDevice;
+    std::vector<vk::LayerProperties> properties = physicalDevice.enumerateDeviceLayerProperties();
+  }
+  {
+    vk::PhysicalDevice physicalDevice;
+    using Allocator = std::allocator<vk::LayerProperties>;
+    Allocator                                   allocator;
+    std::vector<vk::LayerProperties, Allocator> properties = physicalDevice.enumerateDeviceLayerProperties( allocator );
+  }
+
+  // Queue commands
+  {
+    vk::Device device;
+    uint32_t   queueFamilyIndex = 0;
+    uint32_t   queueIndex       = 0;
+    vk::Queue  queue;
+    device.getQueue( queueFamilyIndex, queueIndex, &queue );
+  }
+  {
+    vk::Device device;
+    uint32_t   queueFamilyIndex = 0;
+    uint32_t   queueIndex       = 0;
+    vk::Queue  queue            = device.getQueue( queueFamilyIndex, queueIndex );
+  }
+
+  {
+    vk::Queue      queue;
+    uint32_t       submitCount = 1;
+    vk::SubmitInfo submitInfo;
+    vk::Fence      fence;
+    vk::Result     result = queue.submit( submitCount, &submitInfo, fence );
+  }
+  {
+    vk::Queue      queue;
+    vk::SubmitInfo submitInfo;
+    vk::Fence      fence;
+    queue.submit( submitInfo, fence );
+  }
+
+  {
+    vk::Queue queue;
+    queue.waitIdle();
+  }
+
+  {
+    vk::Device device;
+    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"
@@ -105,6 +106,198 @@ 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
+  {
+    vk::raii::Context                    context;
+    std::vector<vk::ExtensionProperties> properties = context.enumerateInstanceExtensionProperties( nullptr );
+  }
+
+  {
+    vk::raii::PhysicalDevice             physicalDevice = nullptr;
+    std::vector<vk::ExtensionProperties> properties     = physicalDevice.enumerateDeviceExtensionProperties( nullptr );
+  }
+
+  // Layer discovery commands
+  {
+    vk::raii::Context                context;
+    std::vector<vk::LayerProperties> properties = context.enumerateInstanceLayerProperties();
+  }
+
+  {
+    vk::raii::PhysicalDevice         physicalDevice = nullptr;
+    std::vector<vk::LayerProperties> properties     = physicalDevice.enumerateDeviceLayerProperties();
+  }
+
+  // Queue commands
+  {
+    vk::raii::Device device           = nullptr;
+    uint32_t         queueFamilyIndex = 0;
+    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;
+    vk::SubmitInfo  submitInfo;
+    vk::Fence       fence;
+    queue.submit( submitInfo, fence );
+  }
+
+  {
+    vk::raii::Queue queue = nullptr;
+    queue.waitIdle();
+  }
+
+  {
+    vk::raii::Device device = nullptr;
+    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/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

tests/NoDefaultDispatcher/CMakeLists.txt

@@ -0,0 +1,21 @@
+# 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.
+
+vulkan_hpp__setup_test( NAME NoDefaultDispatcher )
+if( VULKAN_HPP_ENABLE_CPP20_MODULES )
+    # gcc versions <= 15.x fail to ignore -Winit-list-lifetime when importing vulkan_hpp
+    if ( NOT (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "16") )
+        vulkan_hpp__setup_test( NAME NoDefaultDispatcher CXX_MODULE )
+    endif()
+endif()

tests/NoDefaultDispatcher/NoDefaultDispatcher.cpp

@@ -0,0 +1,31 @@
+// 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
+
+#define VULKAN_HPP_NO_DEFAULT_DISPATCHER
+
+#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/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"

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

tests/UniqueHandleDefaultArguments/UniqueHandleDefaultArguments.cpp

@@ -17,23 +17,25 @@
 // Should be used on 64 bit only, as on 32 bit the test is ambiguous.
 
 #ifdef VULKAN_HPP_USE_CXX_MODULE
-  #include <vulkan/vulkan.h>
-  import vulkan_hpp;
+#  include <vulkan/vulkan.h>
+import vulkan_hpp;
 #else
 #  include "vulkan/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"

vk_raii_ProgrammingGuide.md

@@ -63,7 +63,7 @@ That is, calling a device-related function is identical for both cases:
     // call waitIdle from a vk::raii::Device
     device.waitIdle();
 
-vk::raii goes one step further. In the vk namespace, most of the functions are members of `vk::Device`. In the vk::raii namespace functions strongly related to a non-dispatchable handle are members of the corresponding vi::raii object. For example, to bind memory to a buffer, in vk namespace you write
+vk::raii goes one step further. In the vk namespace, most of the functions are members of `vk::Device`. In the vk::raii namespace functions strongly related to a non-dispatchable handle are members of the corresponding vk::raii object. For example, to bind memory to a buffer, in vk namespace you write
 
     // bind vk::DeviceMemory memory to a vk::Buffer buffer, given vk::DeviceSize memoryOffset
     device.bindBufferMemory( buffer, memory, memoryOffset );

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>
   {
@@ -13489,6 +13853,21 @@ namespace std
     }
   };
 
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR>
+  {
+    std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR const & physicalDeviceShaderFmaFeaturesKHR ) const VULKAN_HPP_NOEXCEPT
+    {
+      std::size_t seed = 0;
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.sType );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.pNext );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat16 );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat32 );
+      VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat64 );
+      return seed;
+    }
+  };
+
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
   {
@@ -13830,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>
   {
@@ -15130,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>
   {
@@ -16707,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>
   {
@@ -16867,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>
   {
@@ -16882,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;
     }
   };
@@ -16978,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>
   {
@@ -17974,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_ENABLE_STD_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,14 +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

@@ -10,7 +10,7 @@
 
 #include <vulkan/vulkan.hpp>
 
-#if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) )
+#if !defined( VULKAN_HPP_CXX_MODULE )
 #  include <atomic>  // std::atomic_size_t
 #endif
 
@@ -84,7 +84,7 @@ namespace VULKAN_HPP_NAMESPACE
   template <typename DestructorType, typename Deleter>
   struct SharedHeader
   {
-    SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
+    SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT
       : parent( std::move( parent ) )
       , deleter( std::move( deleter ) )
     {
@@ -97,7 +97,7 @@ namespace VULKAN_HPP_NAMESPACE
   template <typename Deleter>
   struct SharedHeader<NoDestructor, Deleter>
   {
-    SharedHeader( Deleter deleter = Deleter() ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
+    SharedHeader( Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
 
     Deleter deleter;
   };
@@ -131,7 +131,7 @@ namespace VULKAN_HPP_NAMESPACE
 
   public:
     std::atomic_size_t m_ref_cnt{ 1 };
-    HeaderType         m_header{};
+    HeaderType         m_header;
   };
 
   //=====================================================================================================================
@@ -282,7 +282,9 @@ namespace VULKAN_HPP_NAMESPACE
     SharedHandle() = default;
 
     template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value && !HasPoolType<T>::value>::type>
-    explicit SharedHandle( HandleType handle, SharedHandle<DestructorTypeOf<HandleType>> parent, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
+    explicit SharedHandle( HandleType                                 handle,
+                           SharedHandle<DestructorTypeOf<HandleType>> parent,
+                           DeleterType deleter                        VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
       : BaseType( handle, std::move( parent ), std::move( deleter ) )
     {
     }
@@ -299,7 +301,8 @@ namespace VULKAN_HPP_NAMESPACE
     }
 
     template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
-    explicit SharedHandle( HandleType handle, DeleterType deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT : BaseType( handle, std::move( deleter ) )
+    explicit SharedHandle( HandleType handle, DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
+      : BaseType( handle, std::move( deleter ) )
     {
     }
 
@@ -318,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,
@@ -332,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 )
       {
@@ -357,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 )
       {
@@ -388,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 )
       {
       }
 
@@ -417,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:
@@ -429,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 ) )
       {
@@ -453,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{};
     };
 
@@ -520,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>
   {
@@ -550,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>
   {
@@ -580,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>
   {
@@ -680,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>
   {
@@ -723,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>
@@ -1052,7 +1045,7 @@ namespace VULKAN_HPP_NAMESPACE
   struct ImageHeader : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>
   {
     ImageHeader( SharedHandle<DestructorTypeOf<Image>>               parent,
-                 typename SharedHandleTraits<Image>::deleter deleter        = typename SharedHandleTraits<Image>::deleter(),
+                 typename SharedHandleTraits<Image>::deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<Image>::deleter() ),
                  SwapchainOwns                                       swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
       : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>( std::move( parent ), std::move( deleter ) )
       , swapchainOwned( swapchainOwned )
@@ -1074,8 +1067,8 @@ namespace VULKAN_HPP_NAMESPACE
 
     explicit SharedHandle( Image                                 handle,
                            SharedHandle<DestructorTypeOf<Image>> parent,
-                           SwapchainOwns                         swapchain_owned = SwapchainOwns::no,
-                           DeleterType                           deleter         = DeleterType() ) VULKAN_HPP_NOEXCEPT
+                           SwapchainOwns swapchain_owned         VULKAN_HPP_DEFAULT_ASSIGNMENT( SwapchainOwns::no ),
+                           DeleterType deleter                   VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
       : BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
     {
     }
@@ -1094,16 +1087,17 @@ namespace VULKAN_HPP_NAMESPACE
   {
     SwapchainHeader( SharedHandle<SurfaceKHR>                     surface,
                      SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
-                     typename SharedHandleTraits<SwapchainKHR>::deleter deleter = typename SharedHandleTraits<SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
+                     typename SharedHandleTraits<SwapchainKHR>::deleter deleter
+                       VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<SwapchainKHR>::deleter() ) ) VULKAN_HPP_NOEXCEPT
       : surface( std::move( surface ) )
       , parent( std::move( parent ) )
       , deleter( std::move( deleter ) )
     {
     }
 
-    SharedHandle<SurfaceKHR>                           surface{};
-    SharedHandle<DestructorTypeOf<SwapchainKHR>>       parent{};
-    typename SharedHandleTraits<SwapchainKHR>::deleter deleter{};
+    SharedHandle<SurfaceKHR>                           surface;
+    SharedHandle<DestructorTypeOf<SwapchainKHR>>       parent;
+    typename SharedHandleTraits<SwapchainKHR>::deleter deleter;
   };
 
   template <>
@@ -1119,7 +1113,7 @@ namespace VULKAN_HPP_NAMESPACE
     explicit SharedHandle( SwapchainKHR                                 handle,
                            SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
                            SharedHandle<SurfaceKHR>                     surface,
-                           DeleterType                                  deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
+                           DeleterType deleter                          VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
       : BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
     {
     }

vulkan/vulkan_video.cppm

@@ -10,11 +10,6 @@
 module;
 
 #include <vulkan/vulkan_hpp_macros.hpp>
-
-#if defined( __cpp_lib_modules ) && !defined( VULKAN_HPP_ENABLE_STD_MODULE )
-#  define VULKAN_HPP_ENABLE_STD_MODULE
-#endif
-
 #include <vulkan/vulkan_video.hpp>
 
 export module vulkan_video_hpp;