use assert macros (#2352)

* add windows ci testing clang and ninja

* attempt to use multi-config builds on msvc ci

* install deps for windows ci

* temporarily disable ci portions

* try clang-cl

* test x64 only

* try x64 for clang-cl

* specify clang-cl as C compiler

* attempt clang-cl with dep install

* ignore unused variable warning in sample02

* need to specify c compiler as glfw install is not being found

* try to ignore warning in standard clang fashion

* syntax fix

* cast procaddress to void* before final func type cast

* added more windows clang warning suppressions

* disable normal windows ci

* suppress warnings in raii samples

* suppress more warnings for tests

* more unused var suppressions for tests

* disable preinstall of deps in clang to prevent _ITERATOR_DEBUG_LEVEL mismatch

* suppress unused var warnings triggered in release mode

* add warning suppression to flags test

* fixed strided array proxy test

* fix structure chain test

* fix extension inspection test

* reenable all ci workflows

.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,32 +31,35 @@ jobs:
     # - name: Install glm, glfw and glslang
     #   run: |
     #     cd glm
-    #     cmake -B build                               \
-    #       -D CMAKE_CXX_STANDARD=11                   \
-    #       -D CMAKE_BUILD_TYPE=Release                \
-    #       -D GLM_BUILD_LIBRARY=ON                    \
-    #       -D GLM_BUILD_INSTALL=ON                    \
+    #     cmake -B build -G Ninja          \
+    #       -D CMAKE_CXX_COMPILER=clang-cl \
+    #       -D CMAKE_CXX_STANDARD=11       \
+    #       -D CMAKE_BUILD_TYPE=Release    \
+    #       -D GLM_BUILD_LIBRARY=ON        \
+    #       -D GLM_BUILD_INSTALL=ON        \
     #       -D GLM_BUILD_TESTS=OFF
     #     cmake --build build --parallel
     #     cmake --install build
 
     #     cd ../glfw
-    #     cmake -B build                               \
-    #       -D CMAKE_CXX_STANDARD=11                   \
-    #       -D CMAKE_BUILD_TYPE=Release                \
-    #       -D GLFW_BUILD_EXAMPLES=OFF                 \
-    #       -D GLFW_BUILD_TESTS=OFF                    \
-    #       -D GLFW_BUILD_DOCS=OFF                     \
+    #     cmake -B build -G Ninja          \
+    #       -D CMAKE_C_COMPILER=clang-cl   \
+    #       -D CMAKE_BUILD_TYPE=Release    \
+    #       -D GLFW_BUILD_EXAMPLES=OFF     \
+    #       -D GLFW_BUILD_TESTS=OFF        \
+    #       -D GLFW_BUILD_DOCS=OFF         \
     #       -D GLFW_INSTALL=ON
     #     cmake --build build --parallel
     #     cmake --install build
 
     #     cd ../glslang
-    #     cmake -B build                               \
-    #       -D CMAKE_CXX_STANDARD=11                   \
-    #       -D CMAKE_BUILD_TYPE=Release                \
-    #       -D ENABLE_OPT=OFF                          \
-    #       -D GLSLANG_TESTS_DEFAULT=OFF               \
+    #     cmake -B build -G Ninja          \
+    #       -D CMAKE_C_COMPILER=clang-cl   \
+    #       -D CMAKE_CXX_COMPILER=clang-cl \
+    #       -D CMAKE_CXX_STANDARD=11       \
+    #       -D CMAKE_BUILD_TYPE=Release    \
+    #       -D ENABLE_OPT=OFF              \
+    #       -D GLSLANG_TESTS_DEFAULT=OFF   \
     #       -D GLSLANG_ENABLE_INSTALL_DEFAULT=ON
     #     cmake --build build --parallel
     #     cmake --install build
@@ -64,7 +67,7 @@ jobs:
 
     - name: Generate headers
       run: |
-        cmake -B build                                 \
+        cmake -B build -G Ninja                        \
           -D VULKAN_HPP_GENERATOR_BUILD=ON             \
           -D VULKAN_HPP_RUN_GENERATOR=OFF              \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
@@ -72,10 +75,12 @@ jobs:
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
+          -D CMAKE_BUILD_TYPE=Debug                    \
+          -D CMAKE_CXX_COMPILER=clang-cl               \
           -D CMAKE_CXX_STANDARD=20
-        cmake --build build --parallel --config Debug
+        cmake --build build --parallel
 
-        cmake -B build --fresh                         \
+        cmake -B build -G Ninja --fresh                \
           -D VULKAN_HPP_GENERATOR_BUILD=ON             \
           -D VULKAN_HPP_RUN_GENERATOR=ON               \
           -D VULKAN_HPP_SAMPLES_BUILD=OFF              \
@@ -83,23 +88,20 @@ jobs:
           -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON     \
           -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON \
           -D VULKAN_HPP_PRECOMPILE=OFF                 \
+          -D CMAKE_BUILD_TYPE=Release                  \
+          -D CMAKE_CXX_COMPILER=clang-cl               \
           -D CMAKE_CXX_STANDARD=20
-        cmake --build build --parallel --clean-first  --config Release
+        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                  \
@@ -107,7 +109,10 @@ jobs:
               -D VULKAN_HPP_DISPATCH_LOADER_DYNAMIC=ON        \
               -D VULKAN_HPP_BUILD_WITH_LOCAL_VULKAN_HPP=ON    \
               -D VULKAN_HPP_PRECOMPILE=OFF                    \
+              -D CMAKE_BUILD_TYPE=$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 --config $BUILD_TYPE
+            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

RAII_Samples/EnableValidationWithCallback/EnableValidationWithCallback.cpp

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

RAII_Samples/InitTexture/InitTexture.cpp

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

RAII_Samples/PipelineCache/PipelineCache.cpp

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

Vulkan-Headers

@@ -1 +1 @@
-Subproject commit 766aaabe571fa32c53606085775340b78ab8d728
+Subproject commit 3dda5a1a87b62fdf3baf4680edc41c00e85a7a22

VulkanHppGenerator.cpp

@@ -1680,9 +1680,12 @@ void VulkanHppGenerator::extendSpecialCommands( std::string const & name, bool d
     template <typename HandleType>
     VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name ) const
     {
-      static_assert( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
-      VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo(
-        handle.objectType, reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) ), name.c_str() );
+      VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
+      // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
+      VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo;
+      nameInfo.objectType   = handle.objectType;
+      nameInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
+      nameInfo.pObjectName  = name.c_str();
       return setDebugUtilsObjectNameEXT( nameInfo );
     }
 )" );
@@ -1711,9 +1714,12 @@ void VulkanHppGenerator::extendSpecialCommands( std::string const & name, bool d
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
                                           Device::setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name, Dispatch const & d ) const
   {
-    static_assert( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
-    VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo(
-      handle.objectType, reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) ), name.c_str() );
+    VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
+    // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
+    VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo;
+    nameInfo.objectType   = handle.objectType;
+    nameInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
+    nameInfo.pObjectName  = name.c_str();
     return setDebugUtilsObjectNameEXT( nameInfo, d );
   }
 )" );
@@ -1743,9 +1749,14 @@ void VulkanHppGenerator::extendSpecialCommands( std::string const & name, bool d
     VULKAN_HPP_INLINE typename ResultValueType<void>::type
       Device::setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag ) const
     {
-      static_assert( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
-      VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo(
-        handle.objectType, reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) ), name, sizeof( TagType ), &tag );
+      VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
+      // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
+      VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo;
+      tagInfo.objectType   = handle.objectType;
+      tagInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
+      tagInfo.tagName      = name;
+      tagInfo.tagSize      = sizeof( TagType );
+      tagInfo.pTag         = &tag;
       return setDebugUtilsObjectTagEXT( tagInfo );
     }
 )" );
@@ -1774,9 +1785,14 @@ void VulkanHppGenerator::extendSpecialCommands( std::string const & name, bool d
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
     Device::setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag, Dispatch const & d ) const
   {
-    static_assert( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
-    VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo(
-      handle.objectType, reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) ), name, sizeof( TagType ), &tag );
+    VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
+    // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
+    VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo;
+    tagInfo.objectType   = handle.objectType;
+    tagInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
+    tagInfo.tagName      = name;
+    tagInfo.tagSize      = sizeof( TagType );
+    tagInfo.pTag         = &tag;
     return setDebugUtilsObjectTagEXT( tagInfo, d );
   }
 )" );
@@ -3620,7 +3636,7 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors2Retu
           else if ( name == "vkGetDeviceFaultInfoEXT" )
           {
             // can't generate an enhanced version for such a complex command! Just use the standard version
-            return generateCommandStandard( name, commandData, initialSkipCount, definition );
+            return generateCommandSetInclusive( name, commandData, initialSkipCount, definition, returnParams, vectorParams, false, {}, raii, false, {} );
           }
         }
         break;
@@ -3628,7 +3644,7 @@ std::string VulkanHppGenerator::generateCommandResultMultiSuccessWithErrors2Retu
         if ( ( returnParams[0] == vectorParams.begin()->first ) && vectorParams.begin()->second.byStructure )
         {
           // can't generate an enhanced version for such a complex command! Just use the standard version
-          return generateCommandStandard( name, commandData, initialSkipCount, definition );
+          return generateCommandSetInclusive( name, commandData, initialSkipCount, definition, returnParams, vectorParams, false, {}, raii, false, {} );
         }
         else if ( returnParams[0] == vectorParams.begin()->second.lenParam )
         {

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

snippets/DynamicLoader.hpp

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

snippets/ExtensionInspectionHppTemplate.hpp

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

snippets/HppTemplate.hpp

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

snippets/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/StructsHppTemplate.hpp

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

snippets/StructureChain.hpp

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

snippets/includes.hpp

@@ -27,7 +27,6 @@
 #else
 #  include <cassert>
 #  include <cstring>
-#  include <cstdlib>
 import std.compat;
 #endif
 #include <vulkan/${vulkan_h}>

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/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,15 +15,15 @@
 // 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>
+#  include <vulkan/vulkan_format_traits.hpp>
 #endif
 
 int main( int /*argc*/, char ** /*argv*/ )

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"

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"

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/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/Video/Video.cpp

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

vulkan/vulkan.cppm

@@ -1048,6 +1048,9 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagBitsARM;
   using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsARM;
 
+  //=== VK_QCOM_data_graph_model ===
+  using VULKAN_HPP_NAMESPACE::DataGraphModelCacheTypeQCOM;
+
   //=== VK_KHR_maintenance10 ===
   using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagBitsKHR;
   using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsKHR;
@@ -2975,6 +2978,11 @@ export namespace VULKAN_HPP_NAMESPACE
   using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingExtensionName;
   using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingSpecVersion;
 
+  //=== VK_QCOM_data_graph_model ===
+  using VULKAN_HPP_NAMESPACE::DataGraphModelToolchainVersionLengthQCOM;
+  using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelExtensionName;
+  using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelSpecVersion;
+
   //=== VK_KHR_maintenance10 ===
   using VULKAN_HPP_NAMESPACE::KHRMaintenance10ExtensionName;
   using VULKAN_HPP_NAMESPACE::KHRMaintenance10SpecVersion;
@@ -5274,6 +5282,11 @@ export namespace VULKAN_HPP_NAMESPACE
   //=== VK_EXT_shader_64bit_indexing ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT;
 
+  //=== VK_QCOM_data_graph_model ===
+  using VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM;
+  using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM;
+  using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM;
+
   //=== VK_KHR_maintenance10 ===
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR;
   using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR;
@@ -9335,6 +9348,14 @@ export namespace std
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT>;
 
+  //=== VK_QCOM_data_graph_model ===
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>;
+  template <>
+  struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>;
+
   //=== VK_KHR_maintenance10 ===
   template <>
   struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR>;
@@ -9365,7 +9386,8 @@ export namespace std
 #endif
 }  // namespace std
 
-export {
+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;

vulkan/vulkan.hpp

@@ -36,7 +36,6 @@
 #  endif
 #else
 #  include <cassert>
-#  include <cstdlib>
 #  include <cstring>
 import std.compat;
 #endif
@@ -58,7 +57,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  endif
 #endif
 
-static_assert( VK_HEADER_VERSION == 331, "Wrong VK_HEADER_VERSION!" );
+VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 332, "Wrong VK_HEADER_VERSION!" );
 
 // <tuple> includes <sys/sysmacros.h> through some other header
 // this results in major(x) being resolved to gnu_dev_major(x)
@@ -151,7 +150,7 @@ namespace VULKAN_HPP_NAMESPACE
   private:
     VULKAN_HPP_CONSTEXPR_14 void copy( char const * data, size_t len ) VULKAN_HPP_NOEXCEPT
     {
-      size_t n = ( std::min )( N - 1, len );
+      size_t n = (std::min)( N - 1, len );
       for ( size_t i = 0; i < n; ++i )
       {
         ( *this )[i] = data[i];
@@ -663,13 +662,13 @@ namespace VULKAN_HPP_NAMESPACE
   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 ) ),
@@ -678,7 +677,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     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>();
     }
 
@@ -738,7 +737,7 @@ namespace VULKAN_HPP_NAMESPACE
     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>() ) );
     }
 
@@ -746,7 +745,7 @@ namespace VULKAN_HPP_NAMESPACE
     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 ) );
@@ -758,7 +757,7 @@ namespace VULKAN_HPP_NAMESPACE
     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>() ) );
     }
 
@@ -7344,25 +7343,25 @@ namespace VULKAN_HPP_NAMESPACE
 
     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;
     }
   };
@@ -7614,6 +7613,9 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_NV_partitioned_acceleration_structure ===
   VULKAN_HPP_CONSTEXPR_INLINE uint32_t PartitionedAccelerationStructurePartitionIndexGlobalNV = VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV;
 
+  //=== VK_QCOM_data_graph_model ===
+  VULKAN_HPP_CONSTEXPR_INLINE uint32_t DataGraphModelToolchainVersionLengthQCOM = VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM;
+
   //========================
   //=== CONSTEXPR VALUEs ===
   //========================
@@ -9530,6 +9532,10 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingExtensionName = VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingSpecVersion   = VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION;
 
+  //=== VK_QCOM_data_graph_model ===
+  VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelExtensionName = VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME;
+  VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelSpecVersion   = VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION;
+
   //=== VK_KHR_maintenance10 ===
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10ExtensionName = VK_KHR_MAINTENANCE_10_EXTENSION_NAME;
   VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10SpecVersion   = VK_KHR_MAINTENANCE_10_SPEC_VERSION;
@@ -19702,6 +19708,34 @@ namespace VULKAN_HPP_NAMESPACE
     };
   };
 
+  //=== VK_QCOM_data_graph_model ===
+  template <>
+  struct StructExtends<DataGraphPipelineBuiltinModelCreateInfoQCOM, DataGraphPipelineCreateInfoARM>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceDataGraphModelFeaturesQCOM, PhysicalDeviceFeatures2>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
+  template <>
+  struct StructExtends<PhysicalDeviceDataGraphModelFeaturesQCOM, DeviceCreateInfo>
+  {
+    enum
+    {
+      value = true
+    };
+  };
+
   //=== VK_KHR_maintenance10 ===
   template <>
   struct StructExtends<PhysicalDeviceMaintenance10FeaturesKHR, PhysicalDeviceFeatures2>
@@ -19893,9 +19927,9 @@ namespace VULKAN_HPP_NAMESPACE
       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

vulkan/vulkan_enums.hpp

@@ -1733,6 +1733,8 @@ namespace VULKAN_HPP_NAMESPACE
     ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR,
     ePhysicalDevicePresentModeFifoLatestReadyFeaturesEXT      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT,
     ePhysicalDeviceShader64BitIndexingFeaturesEXT             = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT,
+    ePhysicalDeviceDataGraphModelFeaturesQCOM                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM,
+    eDataGraphPipelineBuiltinModelCreateInfoQCOM              = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM,
     ePhysicalDeviceMaintenance10FeaturesKHR                   = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR,
     ePhysicalDeviceMaintenance10PropertiesKHR                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR,
     eRenderingAttachmentFlagsInfoKHR                          = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR,
@@ -3191,7 +3193,8 @@ namespace VULKAN_HPP_NAMESPACE
   // wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html
   enum class PipelineCacheHeaderVersion
   {
-    eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
+    eOne           = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
+    eDataGraphQCOM = VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM
   };
 
   // wrapper class for enum VkEventCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateFlagBits.html
@@ -8805,14 +8808,18 @@ namespace VULKAN_HPP_NAMESPACE
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineTypeARM.html
   enum class PhysicalDeviceDataGraphProcessingEngineTypeARM
   {
-    eDefault = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM
+    eDefault     = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM,
+    eNeuralQCOM  = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM,
+    eComputeQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM
   };
 
   // wrapper class for enum VkPhysicalDeviceDataGraphOperationTypeARM, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationTypeARM.html
   enum class PhysicalDeviceDataGraphOperationTypeARM
   {
-    eSpirvExtendedInstructionSet = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM
+    eSpirvExtendedInstructionSet = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM,
+    eNeuralModelQCOM             = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM,
+    eBuiltinModelQCOM            = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM
   };
 
   //=== VK_KHR_video_encode_av1 ===
@@ -9405,6 +9412,14 @@ namespace VULKAN_HPP_NAMESPACE
     static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsARM allFlags  = {};
   };
 
+  //=== VK_QCOM_data_graph_model ===
+
+  // wrapper class for enum VkDataGraphModelCacheTypeQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphModelCacheTypeQCOM.html
+  enum class DataGraphModelCacheTypeQCOM
+  {
+    eGenericBinary = VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM
+  };
+
   //=== VK_KHR_maintenance10 ===
 
   // wrapper class for enum VkRenderingAttachmentFlagBitsKHR, see

vulkan/vulkan_extension_inspection.hpp

@@ -508,6 +508,7 @@ namespace VULKAN_HPP_NAMESPACE
                                                             "VK_EXT_zero_initialize_device_memory",
                                                             "VK_KHR_present_mode_fifo_latest_ready",
                                                             "VK_EXT_shader_64bit_indexing",
+                                                            "VK_QCOM_data_graph_model",
                                                             "VK_KHR_maintenance10",
                                                             "VK_SEC_pipeline_cache_incremental_mode",
                                                             "VK_EXT_shader_uniform_buffer_unsized_array" };
@@ -1782,7 +1783,17 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
-          { "VK_VERSION_1_1", { {} } } } },
+          { "VK_VERSION_1_1", { {} } } } }
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+      ,
+      { "VK_NV_cuda_kernel_launch",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } }
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      ,
       { "VK_QCOM_tile_shading",
         { { "VK_VERSION_1_0",
             { {
@@ -2059,6 +2070,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_frame_boundary",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_multisampled_render_to_single_sampled",
         { { "VK_VERSION_1_0",
             { {
@@ -2179,6 +2196,12 @@ namespace VULKAN_HPP_NAMESPACE
             } } } } },
       { "VK_KHR_maintenance4", { { "VK_VERSION_1_1", { {} } } } },
       { "VK_ARM_shader_core_properties", { { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_subgroup_rotate",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_ARM_scheduling_controls",
         { { "VK_VERSION_1_0",
             { {
@@ -2382,7 +2405,13 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_dynamic_rendering",
             } } },
-          { "VK_VERSION_1_3", { {} } } } }
+          { "VK_VERSION_1_3", { {} } } } },
+      { "VK_AMD_anti_lag",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } }
 #if defined( VK_ENABLE_BETA_EXTENSIONS )
       ,
       { "VK_AMDX_dense_geometry_format",
@@ -2476,6 +2505,18 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_ray_tracing_pipeline",
             } } } } },
+      { "VK_NV_cooperative_vector",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_extended_sparse_address_space",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_mutable_descriptor_type",
         { { "VK_VERSION_1_0",
             { {
@@ -2539,6 +2580,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_deferred_host_operations",
               "VK_KHR_maintenance5",
             } } } } },
+      { "VK_QCOM_multiview_per_view_render_areas",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_compute_shader_derivatives",
         { { "VK_VERSION_1_0",
             { {
@@ -2581,6 +2628,12 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_EXT_filter_cubic",
             } } } } },
+      { "VK_QCOM_ycbcr_degamma",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_QCOM_filter_cubic_clamp",
         { { "VK_VERSION_1_0",
             { {
@@ -2607,6 +2660,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_unified_image_layouts",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_shader_float_controls2",
         { { "VK_VERSION_1_1",
             { {
@@ -2701,7 +2760,49 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_video_encode_queue",
             } } } } },
+      { "VK_NV_raw_access_chains",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_relaxed_extended_instruction",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_command_buffer_inheritance",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_shader_atomic_float16_vector",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_shader_replicated_composites",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_shader_float8",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_NV_ray_tracing_validation",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_NV_cluster_acceleration_structure",
         { { "VK_VERSION_1_0",
             { {
@@ -2730,6 +2831,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_KHR_shader_fma",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_EXT_depth_clamp_control",
         { { "VK_VERSION_1_0",
             { {
@@ -2806,6 +2913,12 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_ARM_format_pack",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
       { "VK_VALVE_fragment_density_map_layered",
         { { "VK_VERSION_1_0",
             { {
@@ -2821,7 +2934,17 @@ namespace VULKAN_HPP_NAMESPACE
             { {
               "VK_KHR_get_physical_device_properties2",
             } } },
-          { "VK_VERSION_1_1", { {} } } } },
+          { "VK_VERSION_1_1", { {} } } } }
+#if defined( VK_ENABLE_BETA_EXTENSIONS )
+      ,
+      { "VK_NV_present_metering",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } }
+#endif /*VK_ENABLE_BETA_EXTENSIONS*/
+      ,
       { "VK_EXT_fragment_density_map_offset",
         { { "VK_VERSION_1_0",
             { {
@@ -2862,7 +2985,24 @@ namespace VULKAN_HPP_NAMESPACE
               "VK_KHR_get_physical_device_properties2",
             } } },
           { "VK_VERSION_1_1", { {} } } } },
+      { "VK_QCOM_data_graph_model",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_ARM_data_graph",
+            } } } } },
       { "VK_KHR_maintenance10",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_SEC_pipeline_cache_incremental_mode",
+        { { "VK_VERSION_1_0",
+            { {
+              "VK_KHR_get_physical_device_properties2",
+            } } },
+          { "VK_VERSION_1_1", { {} } } } },
+      { "VK_EXT_shader_uniform_buffer_unsized_array",
         { { "VK_VERSION_1_0",
             { {
               "VK_KHR_get_physical_device_properties2",
@@ -2878,7 +3018,7 @@ namespace VULKAN_HPP_NAMESPACE
   {
 #if !defined( NDEBUG )
     static std::set<std::string> versions = { "VK_VERSION_1_0", "VK_VERSION_1_1", "VK_VERSION_1_2", "VK_VERSION_1_3", "VK_VERSION_1_4" };
-    assert( versions.find( version ) != versions.end() );
+    VULKAN_HPP_ASSERT( versions.find( version ) != versions.end() );
 #endif
     static std::vector<std::vector<std::string>> noDependencies;
 
@@ -3813,8 +3953,8 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
         || ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) ||
            ( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) ||
-           ( extension == "VK_KHR_maintenance10" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) ||
-           ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" );
+           ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) ||
+           ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) || ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" );
   }
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension )

vulkan/vulkan_funcs.hpp

@@ -15994,9 +15994,12 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
                                           Device::setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name, Dispatch const & d ) const
   {
-    static_assert( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
-    VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo(
-      handle.objectType, reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) ), name.c_str() );
+    VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
+    // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
+    VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo;
+    nameInfo.objectType   = handle.objectType;
+    nameInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
+    nameInfo.pObjectName  = name.c_str();
     return setDebugUtilsObjectNameEXT( nameInfo, d );
   }
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -16033,9 +16036,14 @@ namespace VULKAN_HPP_NAMESPACE
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
     Device::setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag, Dispatch const & d ) const
   {
-    static_assert( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
-    VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo(
-      handle.objectType, reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) ), name, sizeof( TagType ), &tag );
+    VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
+    // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
+    VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo;
+    tagInfo.objectType   = handle.objectType;
+    tagInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
+    tagInfo.tagName      = name;
+    tagInfo.tagSize      = sizeof( TagType );
+    tagInfo.pTag         = &tag;
     return setDebugUtilsObjectTagEXT( tagInfo, d );
   }
 #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@@ -24331,6 +24339,7 @@ namespace VULKAN_HPP_NAMESPACE
     return static_cast<Result>( d.vkGetDeviceFaultInfoEXT(
       static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceFaultCountsEXT *>( pFaultCounts ), reinterpret_cast<VkDeviceFaultInfoEXT *>( pFaultInfo ) ) );
   }
+
 #if defined( VK_USE_PLATFORM_WIN32_KHR )
   //=== VK_NV_acquire_winrt_display ===
 

vulkan/vulkan_handles.hpp

@@ -2247,6 +2247,11 @@ namespace VULKAN_HPP_NAMESPACE
   //=== VK_EXT_shader_64bit_indexing ===
   struct PhysicalDeviceShader64BitIndexingFeaturesEXT;
 
+  //=== VK_QCOM_data_graph_model ===
+  struct PipelineCacheHeaderVersionDataGraphQCOM;
+  struct DataGraphPipelineBuiltinModelCreateInfoQCOM;
+  struct PhysicalDeviceDataGraphModelFeaturesQCOM;
+
   //=== VK_KHR_maintenance10 ===
   struct PhysicalDeviceMaintenance10FeaturesKHR;
   struct PhysicalDeviceMaintenance10PropertiesKHR;
@@ -16407,6 +16412,7 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NODISCARD Result getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts,
                                                  DeviceFaultInfoEXT *   pFaultInfo,
                                                  Dispatch const & d     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+
 #if defined( VK_USE_PLATFORM_FUCHSIA )
     //=== VK_FUCHSIA_external_memory ===
 

vulkan/vulkan_hash.hpp

@@ -3442,6 +3442,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>
   {
@@ -9672,18 +9703,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;
     }
   };
@@ -15423,6 +15451,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>
   {

vulkan/vulkan_raii.hpp

@@ -5276,11 +5276,10 @@ namespace VULKAN_HPP_NAMESPACE
         getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const;
 
       //=== VK_EXT_device_fault ===
+
       // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html
-      template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-      VULKAN_HPP_NODISCARD Result getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts,
-                                                   DeviceFaultInfoEXT *   pFaultInfo,
-                                                   Dispatch const & d     VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
+      VULKAN_HPP_NODISCARD Result getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts, DeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT;
+
 #  if defined( VK_USE_PLATFORM_FUCHSIA )
       //=== VK_FUCHSIA_external_memory ===
 
@@ -21152,9 +21151,12 @@ namespace VULKAN_HPP_NAMESPACE
     template <typename HandleType>
     VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name ) const
     {
-      static_assert( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
-      VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo(
-        handle.objectType, reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) ), name.c_str() );
+      VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
+      // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
+      VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo;
+      nameInfo.objectType   = handle.objectType;
+      nameInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
+      nameInfo.pObjectName  = name.c_str();
       return setDebugUtilsObjectNameEXT( nameInfo );
     }
 
@@ -21176,9 +21178,14 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_INLINE typename ResultValueType<void>::type
       Device::setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag ) const
     {
-      static_assert( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
-      VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo(
-        handle.objectType, reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) ), name, sizeof( TagType ), &tag );
+      VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType<HandleType>::value, "HandleType must be a Vulkan handle type" );
+      // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member
+      VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo;
+      tagInfo.objectType   = handle.objectType;
+      tagInfo.objectHandle = reinterpret_cast<uint64_t>( static_cast<typename HandleType::CType>( handle ) );
+      tagInfo.tagName      = name;
+      tagInfo.tagSize      = sizeof( TagType );
+      tagInfo.pTag         = &tag;
       return setDebugUtilsObjectTagEXT( tagInfo );
     }
 
@@ -24783,15 +24790,13 @@ namespace VULKAN_HPP_NAMESPACE
 
     //=== VK_EXT_device_fault ===
     // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html
-    template <typename Dispatch>
     VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts,
-                                                                           DeviceFaultInfoEXT *   pFaultInfo,
-                                                                           Dispatch const &       d ) const VULKAN_HPP_NOEXCEPT
+                                                                           DeviceFaultInfoEXT *   pFaultInfo ) const VULKAN_HPP_NOEXCEPT
     {
-      VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-      return static_cast<Result>( d.vkGetDeviceFaultInfoEXT( static_cast<VkDevice>( m_device ),
-                                                             reinterpret_cast<VkDeviceFaultCountsEXT *>( pFaultCounts ),
-                                                             reinterpret_cast<VkDeviceFaultInfoEXT *>( pFaultInfo ) ) );
+      VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultInfoEXT && "Function <vkGetDeviceFaultInfoEXT> requires <VK_EXT_device_fault>" );
+      return static_cast<Result>( getDispatcher()->vkGetDeviceFaultInfoEXT( static_cast<VkDevice>( m_device ),
+                                                                            reinterpret_cast<VkDeviceFaultCountsEXT *>( pFaultCounts ),
+                                                                            reinterpret_cast<VkDeviceFaultInfoEXT *>( pFaultInfo ) ) );
     }
 #  if defined( VK_USE_PLATFORM_WIN32_KHR )
     //=== VK_NV_acquire_winrt_display ===

vulkan/vulkan_static_assertions.hpp

@@ -9423,6 +9423,30 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::Physical
 VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT>::value,
                           "PhysicalDeviceShader64BitIndexingFeaturesEXT is not nothrow_move_constructible!" );
 
+//=== VK_QCOM_data_graph_model ===
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM ) == sizeof( VkPipelineCacheHeaderVersionDataGraphQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM>::value,
+                          "PipelineCacheHeaderVersionDataGraphQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM ) ==
+                            sizeof( VkDataGraphPipelineBuiltinModelCreateInfoQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM>::value,
+                          "DataGraphPipelineBuiltinModelCreateInfoQCOM is not nothrow_move_constructible!" );
+
+VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM ) == sizeof( VkPhysicalDeviceDataGraphModelFeaturesQCOM ),
+                          "struct and wrapper have different size!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>::value,
+                          "struct wrapper is not a standard layout!" );
+VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM>::value,
+                          "PhysicalDeviceDataGraphModelFeaturesQCOM is not nothrow_move_constructible!" );
+
 //=== VK_KHR_maintenance10 ===
 
 VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance10FeaturesKHR ),

vulkan/vulkan_structs.hpp

@@ -12,7 +12,6 @@
 // IWYU pragma: private, include "vulkan/vulkan.hpp"
 
 #if !defined( VULKAN_HPP_CXX_MODULE )
-#  include <cstdlib>  // free
 #  include <cstring>  // strcmp
 #endif
 
@@ -28354,6 +28353,269 @@ namespace VULKAN_HPP_NAMESPACE
   };
 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
 
+  // wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html
+  struct PhysicalDeviceDataGraphOperationSupportARM
+  {
+    using NativeType = VkPhysicalDeviceDataGraphOperationSupportARM;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM(
+      PhysicalDeviceDataGraphOperationTypeARM operationType_ = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet,
+      std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const & name_    = {},
+      uint32_t                                                                                version_ = {} ) VULKAN_HPP_NOEXCEPT
+      : operationType{ operationType_ }
+      , name{ name_ }
+      , version{ version_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PhysicalDeviceDataGraphOperationSupportARM( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceDataGraphOperationSupportARM( *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs ) )
+    {
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationTypeARM operationType_, std::string const & name_, uint32_t version_ = {} )
+      : operationType( operationType_ ), version( version_ )
+    {
+      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
+#    if defined( _WIN32 )
+      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
+#    else
+      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
+#    endif
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    PhysicalDeviceDataGraphOperationSupportARM & operator=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    PhysicalDeviceDataGraphOperationSupportARM & operator=( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
+      setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) VULKAN_HPP_NOEXCEPT
+    {
+      operationType = operationType_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
+      setName( std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name_ ) VULKAN_HPP_NOEXCEPT
+    {
+      name = name_;
+      return *this;
+    }
+
+#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+    PhysicalDeviceDataGraphOperationSupportARM & setName( std::string const & name_ ) VULKAN_HPP_NOEXCEPT
+    {
+      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
+#    if defined( _WIN32 )
+      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
+#    else
+      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
+#    endif
+      return *this;
+    }
+#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setVersion( uint32_t version_ ) VULKAN_HPP_NOEXCEPT
+    {
+      version = version_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
+    operator VkPhysicalDeviceDataGraphOperationSupportARM const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+    }
+
+    operator VkPhysicalDeviceDataGraphOperationSupportARM &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+    }
+
+    operator VkPhysicalDeviceDataGraphOperationSupportARM const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+    }
+
+    operator VkPhysicalDeviceDataGraphOperationSupportARM *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<PhysicalDeviceDataGraphOperationTypeARM const &,
+               ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const &,
+               uint32_t const &>
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( operationType, name, version );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    std::strong_ordering operator<=>( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      if ( auto cmp = operationType <=> rhs.operationType; cmp != 0 )
+        return cmp;
+      if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 )
+        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
+      if ( auto cmp = version <=> rhs.version; cmp != 0 )
+        return cmp;
+
+      return std::strong_ordering::equivalent;
+    }
+#endif
+
+    bool operator==( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return ( operationType == rhs.operationType ) && ( strcmp( name, rhs.name ) == 0 ) && ( version == rhs.version );
+    }
+
+    bool operator!=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+
+  public:
+    PhysicalDeviceDataGraphOperationTypeARM operationType = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet;
+    ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name    = {};
+    uint32_t                                                                            version = {};
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkPhysicalDeviceDataGraphOperationSupportARM>
+  {
+    using Type = PhysicalDeviceDataGraphOperationSupportARM;
+  };
+#endif
+
+  // wrapper struct for struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineBuiltinModelCreateInfoQCOM.html
+  struct DataGraphPipelineBuiltinModelCreateInfoQCOM
+  {
+    using NativeType = VkDataGraphPipelineBuiltinModelCreateInfoQCOM;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ = {},
+                                                                         const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , pOperation{ pOperation_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR_14
+      DataGraphPipelineBuiltinModelCreateInfoQCOM( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    DataGraphPipelineBuiltinModelCreateInfoQCOM( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+      : DataGraphPipelineBuiltinModelCreateInfoQCOM( *reinterpret_cast<DataGraphPipelineBuiltinModelCreateInfoQCOM const *>( &rhs ) )
+    {
+    }
+
+    DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<DataGraphPipelineBuiltinModelCreateInfoQCOM const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM &
+      setPOperation( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pOperation = pOperation_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
+    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
+    }
+
+    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
+    }
+
+    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<const VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
+    }
+
+    operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkDataGraphPipelineBuiltinModelCreateInfoQCOM *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<StructureType const &, const void * const &, const PhysicalDeviceDataGraphOperationSupportARM * const &> reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( sType, pNext, pOperation );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( DataGraphPipelineBuiltinModelCreateInfoQCOM const & ) const = default;
+#else
+    bool operator==( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pOperation == rhs.pOperation );
+#  endif
+    }
+
+    bool operator!=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    StructureType                                      sType      = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM;
+    const void *                                       pNext      = {};
+    const PhysicalDeviceDataGraphOperationSupportARM * pOperation = {};
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkDataGraphPipelineBuiltinModelCreateInfoQCOM>
+  {
+    using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM;
+  };
+#endif
+
+  template <>
+  struct CppType<StructureType, StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM>
+  {
+    using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM;
+  };
+
   // wrapper struct for struct VkDataGraphPipelineCompilerControlCreateInfoARM, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineCompilerControlCreateInfoARM.html
   struct DataGraphPipelineCompilerControlCreateInfoARM
@@ -82427,155 +82689,117 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PhysicalDeviceDataGraphFeaturesARM;
   };
 
-  // wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see
-  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html
-  struct PhysicalDeviceDataGraphOperationSupportARM
+  // wrapper struct for struct VkPhysicalDeviceDataGraphModelFeaturesQCOM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphModelFeaturesQCOM.html
+  struct PhysicalDeviceDataGraphModelFeaturesQCOM
   {
-    using NativeType = VkPhysicalDeviceDataGraphOperationSupportARM;
+    using NativeType = VkPhysicalDeviceDataGraphModelFeaturesQCOM;
+
+    static const bool                                  allowDuplicate = false;
+    static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType  = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM;
 
 #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM(
-      PhysicalDeviceDataGraphOperationTypeARM operationType_ = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet,
-      std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const & name_    = {},
-      uint32_t                                                                                version_ = {} ) VULKAN_HPP_NOEXCEPT
-      : operationType{ operationType_ }
-      , name{ name_ }
-      , version{ version_ }
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( Bool32 dataGraphModel_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT
+      : pNext{ pNext_ }
+      , dataGraphModel{ dataGraphModel_ }
     {
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 
-    PhysicalDeviceDataGraphOperationSupportARM( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
-      : PhysicalDeviceDataGraphOperationSupportARM( *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs ) )
+    PhysicalDeviceDataGraphModelFeaturesQCOM( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PhysicalDeviceDataGraphModelFeaturesQCOM( *reinterpret_cast<PhysicalDeviceDataGraphModelFeaturesQCOM const *>( &rhs ) )
     {
     }
 
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
-    PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationTypeARM operationType_, std::string const & name_, uint32_t version_ = {} )
-      : operationType( operationType_ ), version( version_ )
-    {
-      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
-#    if defined( _WIN32 )
-      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
-#    else
-      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
-#    endif
-    }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    PhysicalDeviceDataGraphOperationSupportARM & operator=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+    PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
 #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
 
-    PhysicalDeviceDataGraphOperationSupportARM & operator=( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT
+    PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
     {
-      *this = *reinterpret_cast<PhysicalDeviceDataGraphOperationSupportARM const *>( &rhs );
+      *this = *reinterpret_cast<PhysicalDeviceDataGraphModelFeaturesQCOM const *>( &rhs );
       return *this;
     }
 
 #if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
-      setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
     {
-      operationType = operationType_;
+      pNext = pNext_;
       return *this;
     }
 
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM &
-      setName( std::array<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name_ ) VULKAN_HPP_NOEXCEPT
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setDataGraphModel( Bool32 dataGraphModel_ ) VULKAN_HPP_NOEXCEPT
     {
-      name = name_;
-      return *this;
-    }
-
-#  if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
-    PhysicalDeviceDataGraphOperationSupportARM & setName( std::string const & name_ ) VULKAN_HPP_NOEXCEPT
-    {
-      VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM );
-#    if defined( _WIN32 )
-      strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() );
-#    else
-      strncpy( name, name_.data(), std::min<size_t>( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) );
-#    endif
-      return *this;
-    }
-#  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setVersion( uint32_t version_ ) VULKAN_HPP_NOEXCEPT
-    {
-      version = version_;
+      dataGraphModel = dataGraphModel_;
       return *this;
     }
 #endif /*VULKAN_HPP_NO_SETTERS*/
 
-    operator VkPhysicalDeviceDataGraphOperationSupportARM const &() const VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+      return *reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
     }
 
-    operator VkPhysicalDeviceDataGraphOperationSupportARM &() VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceDataGraphModelFeaturesQCOM &() VULKAN_HPP_NOEXCEPT
     {
-      return *reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+      return *reinterpret_cast<VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
     }
 
-    operator VkPhysicalDeviceDataGraphOperationSupportARM const *() const VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT
     {
-      return reinterpret_cast<const VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+      return reinterpret_cast<const VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
     }
 
-    operator VkPhysicalDeviceDataGraphOperationSupportARM *() VULKAN_HPP_NOEXCEPT
+    operator VkPhysicalDeviceDataGraphModelFeaturesQCOM *() VULKAN_HPP_NOEXCEPT
     {
-      return reinterpret_cast<VkPhysicalDeviceDataGraphOperationSupportARM *>( this );
+      return reinterpret_cast<VkPhysicalDeviceDataGraphModelFeaturesQCOM *>( this );
     }
 
 #if defined( VULKAN_HPP_USE_REFLECT )
-    std::tuple<PhysicalDeviceDataGraphOperationTypeARM const &,
-               ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> const &,
-               uint32_t const &>
-      reflect() const VULKAN_HPP_NOEXCEPT
+    std::tuple<StructureType const &, const void * const &, Bool32 const &> reflect() const VULKAN_HPP_NOEXCEPT
     {
-      return std::tie( operationType, name, version );
+      return std::tie( sType, pNext, dataGraphModel );
     }
 #endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
-    std::strong_ordering operator<=>( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    auto operator<=>( PhysicalDeviceDataGraphModelFeaturesQCOM const & ) const = default;
+#else
+    bool operator==( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      if ( auto cmp = operationType <=> rhs.operationType; cmp != 0 )
-        return cmp;
-      if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 )
-        return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater;
-      if ( auto cmp = version <=> rhs.version; cmp != 0 )
-        return cmp;
-
-      return std::strong_ordering::equivalent;
-    }
-#endif
-
-    bool operator==( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
-    {
-      return ( operationType == rhs.operationType ) && ( strcmp( name, rhs.name ) == 0 ) && ( version == rhs.version );
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraphModel == rhs.dataGraphModel );
+#  endif
     }
 
-    bool operator!=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool operator!=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
       return !operator==( rhs );
     }
+#endif
 
   public:
-    PhysicalDeviceDataGraphOperationTypeARM operationType = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet;
-    ArrayWrapper1D<char, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM> name    = {};
-    uint32_t                                                                            version = {};
+    StructureType sType          = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM;
+    const void *  pNext          = {};
+    Bool32        dataGraphModel = {};
   };
 
 #if 20 <= VULKAN_HPP_CPP_VERSION
   template <>
-  struct CppType<VkPhysicalDeviceDataGraphOperationSupportARM>
+  struct CppType<VkPhysicalDeviceDataGraphModelFeaturesQCOM>
   {
-    using Type = PhysicalDeviceDataGraphOperationSupportARM;
+    using Type = PhysicalDeviceDataGraphModelFeaturesQCOM;
   };
 #endif
 
+  template <>
+  struct CppType<StructureType, StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM>
+  {
+    using Type = PhysicalDeviceDataGraphModelFeaturesQCOM;
+  };
+
   // wrapper struct for struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html
   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
@@ -90331,6 +90555,21 @@ namespace VULKAN_HPP_NAMESPACE
       return *this;
     }
 
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
+    {
+      pNext = pNext_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE &
+      setFragmentDensityMapLayered( Bool32 fragmentDensityMapLayered_ ) VULKAN_HPP_NOEXCEPT
+    {
+      fragmentDensityMapLayered = fragmentDensityMapLayered_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
     operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT
     {
       return *reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *>( this );
@@ -126655,6 +126894,143 @@ namespace VULKAN_HPP_NAMESPACE
     using Type = PipelineCacheCreateInfo;
   };
 
+  // wrapper struct for struct VkPipelineCacheHeaderVersionDataGraphQCOM, see
+  // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionDataGraphQCOM.html
+  struct PipelineCacheHeaderVersionDataGraphQCOM
+  {
+    using NativeType = VkPipelineCacheHeaderVersionDataGraphQCOM;
+
+#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM(
+      uint32_t                                                                        headerSize_       = {},
+      PipelineCacheHeaderVersion                                                      headerVersion_    = PipelineCacheHeaderVersion::eOne,
+      DataGraphModelCacheTypeQCOM                                                     cacheType_        = DataGraphModelCacheTypeQCOM::eGenericBinary,
+      uint32_t                                                                        cacheVersion_     = {},
+      std::array<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> const & toolchainVersion_ = {} ) VULKAN_HPP_NOEXCEPT
+      : headerSize{ headerSize_ }
+      , headerVersion{ headerVersion_ }
+      , cacheType{ cacheType_ }
+      , cacheVersion{ cacheVersion_ }
+      , toolchainVersion{ toolchainVersion_ }
+    {
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+
+    PipelineCacheHeaderVersionDataGraphQCOM( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+      : PipelineCacheHeaderVersionDataGraphQCOM( *reinterpret_cast<PipelineCacheHeaderVersionDataGraphQCOM const *>( &rhs ) )
+    {
+    }
+
+    PipelineCacheHeaderVersionDataGraphQCOM & operator=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default;
+#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/
+
+    PipelineCacheHeaderVersionDataGraphQCOM & operator=( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT
+    {
+      *this = *reinterpret_cast<PipelineCacheHeaderVersionDataGraphQCOM const *>( &rhs );
+      return *this;
+    }
+
+#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderSize( uint32_t headerSize_ ) VULKAN_HPP_NOEXCEPT
+    {
+      headerSize = headerSize_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) VULKAN_HPP_NOEXCEPT
+    {
+      headerVersion = headerVersion_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheType( DataGraphModelCacheTypeQCOM cacheType_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cacheType = cacheType_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheVersion( uint32_t cacheVersion_ ) VULKAN_HPP_NOEXCEPT
+    {
+      cacheVersion = cacheVersion_;
+      return *this;
+    }
+
+    VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM &
+      setToolchainVersion( std::array<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> toolchainVersion_ ) VULKAN_HPP_NOEXCEPT
+    {
+      toolchainVersion = toolchainVersion_;
+      return *this;
+    }
+#endif /*VULKAN_HPP_NO_SETTERS*/
+
+    operator VkPipelineCacheHeaderVersionDataGraphQCOM const &() const VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<const VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
+    }
+
+    operator VkPipelineCacheHeaderVersionDataGraphQCOM &() VULKAN_HPP_NOEXCEPT
+    {
+      return *reinterpret_cast<VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
+    }
+
+    operator VkPipelineCacheHeaderVersionDataGraphQCOM const *() const VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<const VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
+    }
+
+    operator VkPipelineCacheHeaderVersionDataGraphQCOM *() VULKAN_HPP_NOEXCEPT
+    {
+      return reinterpret_cast<VkPipelineCacheHeaderVersionDataGraphQCOM *>( this );
+    }
+
+#if defined( VULKAN_HPP_USE_REFLECT )
+    std::tuple<uint32_t const &,
+               PipelineCacheHeaderVersion const &,
+               DataGraphModelCacheTypeQCOM const &,
+               uint32_t const &,
+               ArrayWrapper1D<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> const &>
+      reflect() const VULKAN_HPP_NOEXCEPT
+    {
+      return std::tie( headerSize, headerVersion, cacheType, cacheVersion, toolchainVersion );
+    }
+#endif
+
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+    auto operator<=>( PipelineCacheHeaderVersionDataGraphQCOM const & ) const = default;
+#else
+    bool operator==( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+#  if defined( VULKAN_HPP_USE_REFLECT )
+      return this->reflect() == rhs.reflect();
+#  else
+      return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && ( cacheType == rhs.cacheType ) &&
+             ( cacheVersion == rhs.cacheVersion ) && ( toolchainVersion == rhs.toolchainVersion );
+#  endif
+    }
+
+    bool operator!=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
+    {
+      return !operator==( rhs );
+    }
+#endif
+
+  public:
+    uint32_t                                                                    headerSize       = {};
+    PipelineCacheHeaderVersion                                                  headerVersion    = PipelineCacheHeaderVersion::eOne;
+    DataGraphModelCacheTypeQCOM                                                 cacheType        = DataGraphModelCacheTypeQCOM::eGenericBinary;
+    uint32_t                                                                    cacheVersion     = {};
+    ArrayWrapper1D<uint32_t, VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM> toolchainVersion = {};
+  };
+
+#if 20 <= VULKAN_HPP_CPP_VERSION
+  template <>
+  struct CppType<VkPipelineCacheHeaderVersionDataGraphQCOM>
+  {
+    using Type = PipelineCacheHeaderVersionDataGraphQCOM;
+  };
+#endif
+
   // wrapper struct for struct VkPipelineCacheHeaderVersionOne, see
   // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionOne.html
   struct PipelineCacheHeaderVersionOne

vulkan/vulkan_to_string.hpp

@@ -5564,6 +5564,8 @@ namespace VULKAN_HPP_NAMESPACE
       case StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT     : return "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT";
       case StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR     : return "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR";
       case StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT            : return "PhysicalDeviceShader64BitIndexingFeaturesEXT";
+      case StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM                : return "PhysicalDeviceDataGraphModelFeaturesQCOM";
+      case StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM             : return "DataGraphPipelineBuiltinModelCreateInfoQCOM";
       case StructureType::ePhysicalDeviceMaintenance10FeaturesKHR                  : return "PhysicalDeviceMaintenance10FeaturesKHR";
       case StructureType::ePhysicalDeviceMaintenance10PropertiesKHR                : return "PhysicalDeviceMaintenance10PropertiesKHR";
       case StructureType::eRenderingAttachmentFlagsInfoKHR                         : return "RenderingAttachmentFlagsInfoKHR";
@@ -6589,8 +6591,9 @@ namespace VULKAN_HPP_NAMESPACE
   {
     switch ( value )
     {
-      case PipelineCacheHeaderVersion::eOne: return "One";
-      default                              : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
+      case PipelineCacheHeaderVersion::eOne          : return "One";
+      case PipelineCacheHeaderVersion::eDataGraphQCOM: return "DataGraphQCOM";
+      default                                        : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
 
@@ -10366,8 +10369,10 @@ namespace VULKAN_HPP_NAMESPACE
   {
     switch ( value )
     {
-      case PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault: return "Default";
-      default                                                      : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
+      case PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault    : return "Default";
+      case PhysicalDeviceDataGraphProcessingEngineTypeARM::eNeuralQCOM : return "NeuralQCOM";
+      case PhysicalDeviceDataGraphProcessingEngineTypeARM::eComputeQCOM: return "ComputeQCOM";
+      default                                                          : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
 
@@ -10376,6 +10381,8 @@ namespace VULKAN_HPP_NAMESPACE
     switch ( value )
     {
       case PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet: return "SpirvExtendedInstructionSet";
+      case PhysicalDeviceDataGraphOperationTypeARM::eNeuralModelQCOM            : return "NeuralModelQCOM";
+      case PhysicalDeviceDataGraphOperationTypeARM::eBuiltinModelQCOM           : return "BuiltinModelQCOM";
       default                                                                   : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
     }
   }
@@ -10802,6 +10809,17 @@ namespace VULKAN_HPP_NAMESPACE
     return "(void)";
   }
 
+  //=== VK_QCOM_data_graph_model ===
+
+  VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphModelCacheTypeQCOM value )
+  {
+    switch ( value )
+    {
+      case DataGraphModelCacheTypeQCOM::eGenericBinary: return "GenericBinary";
+      default                                         : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
+    }
+  }
+
   //=== VK_KHR_maintenance10 ===
 
   VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderingAttachmentFlagBitsKHR value )