build: Update to header 1.4.317

Calling memcpy with either src or dst as nullptr is undefined
even if the count is 0.

Discovered by running tests with -fsanitize=undefined

safe_struct.extension_add_remove specifcially

.github/workflows/ci.yml

@@ -1,6 +1,6 @@
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2024 The Khronos Group Inc.
+# Copyright 2023-2024 Valve Corporation
+# Copyright 2023-2024 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -14,27 +14,39 @@ on:
 
 jobs:
   build_and_test:
+    # Use chromium as a test build, so don't run this job unless something simple works first
+    needs: chromium
     runs-on: ${{matrix.os}}
     strategy:
       matrix:
         config: [Debug, Release]
-        os: [ ubuntu-20.04, ubuntu-22.04, windows-latest, macos-latest ]
+        os: [ ubuntu-22.04, ubuntu-24.04, windows-latest, macos-latest ]
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - name: Set up Python 3.8
+        if: matrix.os != 'macos-latest'
+        uses: actions/setup-python@v5
         with:
           python-version: '3.8'
+      # MacOS machine can run on arm64 and it doesn't support 3.8
+      - name: Set up Python 3.10.11
+        if: matrix.os == 'macos-latest'
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10.11'
       - name: Test CMake Minimum
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-22.04'
         uses: lukka/get-cmake@latest
         with:
-          cmakeVersion: 3.17.2
+          cmakeVersion: 3.22.1
       - run: cmake -S. -B build -D VUL_WERROR=ON -D BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=${{matrix.config}} -D UPDATE_DEPS=ON
       - run: cmake --build build --config ${{matrix.config}} --verbose
       - run: ctest -C ${{matrix.config}} --output-on-failure
         working-directory: build/
 
   windows-arm64:
+    # Use chromium as a test build, so don't run this job unless something simple works first
+    needs: chromium
     runs-on: windows-latest
     env:
       CMAKE_GENERATOR: Ninja
@@ -48,7 +60,9 @@ jobs:
       - run: cmake --install build --prefix build/install
 
   android:
-    runs-on: ubuntu-22.04
+    # Use chromium as a test build, so don't run this job unless something simple works first
+    needs: chromium
+    runs-on: ubuntu-24.04
     strategy:
       matrix:
         abi: [ armeabi-v7a, arm64-v8a ]
@@ -78,11 +92,12 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: REUSE Compliance Check
-      uses: fsfe/reuse-action@v2
+      uses: fsfe/reuse-action@v5
 
   # Test to ensure we don't accidentally break the Chromium build.
   chromium:
-    runs-on: ubuntu-22.04
+    needs: generate_source
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
@@ -94,7 +109,7 @@ jobs:
         run: python scripts/gn/gn.py
 
   generate_source:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5

.github/workflows/format.yml

@@ -28,7 +28,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Run clang-format
-      uses: jidicula/clang-format-action@v4.11.0
+      uses: jidicula/clang-format-action@v4.15.0
       with:
         clang-format-version: '14'
         check-path: ${{ matrix.path }}

.gitignore

@@ -10,6 +10,7 @@ build
 .vscode/
 **/.*.swp
 external
+.cache
 
 # Chromium build artifacts
 .cipd/

BUILD.gn

@@ -6,6 +6,7 @@ import("//build_overrides/vulkan_utility_libraries.gni")
 
 config("vulkan_utility_libraries_config") {
   include_dirs = [ "include" ]
+  defines = [ "VK_ENABLE_BETA_EXTENSIONS" ]
 }
 
 static_library("vulkan_layer_settings") {
@@ -14,8 +15,11 @@ static_library("vulkan_layer_settings") {
   sources = [
     "include/vulkan/layer/vk_layer_settings.h",
     "include/vulkan/layer/vk_layer_settings.hpp",
+    "include/vulkan/utility/vk_concurrent_unordered_map.hpp",
     "include/vulkan/utility/vk_dispatch_table.h",
     "include/vulkan/utility/vk_format_utils.h",
+    "include/vulkan/utility/vk_safe_struct.hpp",
+    "include/vulkan/utility/vk_safe_struct_utils.hpp",
     "include/vulkan/utility/vk_struct_helper.hpp",
     "include/vulkan/vk_enum_string_helper.h",
     "scripts/gn/stub.cpp",
@@ -25,5 +29,11 @@ static_library("vulkan_layer_settings") {
     "src/layer/layer_settings_util.hpp",
     "src/layer/vk_layer_settings.cpp",
     "src/layer/vk_layer_settings_helper.cpp",
+    "src/vulkan/vk_safe_struct_core.cpp",
+    "src/vulkan/vk_safe_struct_ext.cpp",
+    "src/vulkan/vk_safe_struct_khr.cpp",
+    "src/vulkan/vk_safe_struct_utils.cpp",
+    "src/vulkan/vk_safe_struct_vendor.cpp",
+    "src/vulkan/vk_safe_struct_manual.cpp",
   ]
 }

BUILD.md

@@ -16,7 +16,7 @@ This document contains the instructions for building this repository on Linux, m
 
 ## Requirements
 
-1. CMake >= 3.17.2
+1. CMake >= 3.22.1
 2. C++ >= c++17 compiler. See platform-specific sections below for supported compiler versions.
 3. Python >= 3.8
 

CMakeLists.txt

@@ -3,12 +3,10 @@
 # Copyright 2023 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
-cmake_minimum_required(VERSION 3.17.2)
+cmake_minimum_required(VERSION 3.22.1)
 
 project(VUL LANGUAGES CXX)
 
-string(COMPARE EQUAL ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR} VUL_IS_TOP_LEVEL) # Remove when min is 3.21
-
 set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Remove when min is 3.26, see CMP0143
 
 set(CMAKE_CXX_STANDARD 17)
@@ -27,30 +25,51 @@ add_subdirectory(scripts)
 
 find_package(VulkanHeaders CONFIG)
 
+option(VUL_ENABLE_ASAN "Use address sanitization")
+if (VUL_ENABLE_ASAN)
+    add_compile_options(-fsanitize=address)
+    if (NOT MSVC)
+        add_link_options(-fsanitize=address)
+    endif()
+endif()
+
+option(VUL_ENABLE_UBSAN "Use undefined behavior sanitization")
+if (VUL_ENABLE_UBSAN)
+    if (NOT MSVC)
+        add_compile_options(-fsanitize=undefined)
+        add_link_options(-fsanitize=undefined)
+    endif()
+endif()
+
 add_subdirectory(src)
 add_subdirectory(include)
 
-if (VUL_IS_TOP_LEVEL)
+if (PROJECT_IS_TOP_LEVEL)
     option(BUILD_TESTS "Build tests")
     if (BUILD_TESTS)
         enable_testing()
         add_subdirectory(tests)
     endif()
+endif()
+
+option(VUL_ENABLE_INSTALL "Enable install" ${PROJECT_IS_TOP_LEVEL})
+if (VUL_ENABLE_INSTALL)
 
     include(GNUInstallDirs)
     include(CMakePackageConfigHelpers)
 
     install(
-        DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/${API_TYPE}/"
+        DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan/"
         DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/vulkan"
     )
 
     # Create VulkanUtilityLibraries-targets.cmake
     set_target_properties(VulkanLayerSettings PROPERTIES EXPORT_NAME "LayerSettings")
     set_target_properties(VulkanUtilityHeaders PROPERTIES EXPORT_NAME "UtilityHeaders")
+    set_target_properties(VulkanSafeStruct PROPERTIES EXPORT_NAME "SafeStruct")
     set_target_properties(VulkanCompilerConfiguration PROPERTIES EXPORT_NAME "CompilerConfiguration")
     install(
-        TARGETS VulkanLayerSettings VulkanUtilityHeaders VulkanCompilerConfiguration
+        TARGETS VulkanLayerSettings VulkanUtilityHeaders VulkanSafeStruct VulkanCompilerConfiguration
         EXPORT VulkanUtilityLibraries-targets
         INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
     )

docs/layer_configuration.md

@@ -92,7 +92,7 @@ Layer settings may be configured using the `VK_EXT_layer_settings` extension by
         {layer_name, "validate_sync", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_validate_sync},
         {layer_name, "thread_safety", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_thread_safety},
         {layer_name, "debug_action", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, setting_debug_action},
-        {layer_name, "report_flags", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(setting_report_flags)), setting_report_flags}
+        {layer_name, "report_flags", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(setting_report_flags)), setting_report_flags},
         {layer_name, "enable_message_limit", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_enable_message_limit},
         {layer_name, "duplicate_message_limit", VK_LAYER_SETTING_TYPE_INT32_EXT, 1, &setting_duplicate_message_limit}};
 
@@ -369,3 +369,13 @@ $ export VK_VALIDATION_REPORT_FLAGS=debug:error:perf:info:warn
 $ export VK_VALIDATION_ENABLE_MESSAGE_LIMIT=true
 $ export VK_VALIDATION_DUPLICATE_MESSAGE_LIMIT=3
 ```
+
+#### Example Usage on Android:
+
+```
+$ adb setprop debug.vvl.validation_core true
+$ adb setprop debug.vulkan.validation.validation_sync true
+$ adb setprop debug.vulkan.validation.thread_safety true
+$ adb setprop debug.vulkan.validation.enable_message_limit true
+$ adb setprop debug.vulkan.validation.duplicate_message_limit 3
+```

include/CMakeLists.txt

@@ -1,13 +1,20 @@
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2024 The Khronos Group Inc.
+# Copyright 2023-2024 Valve Corporation
+# Copyright 2023-2024 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 target_include_directories(VulkanLayerSettings PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
 
 target_sources(VulkanLayerSettings PRIVATE
-	vulkan/layer/vk_layer_settings.h
-	vulkan/layer/vk_layer_settings.hpp
+    vulkan/layer/vk_layer_settings.h
+    vulkan/layer/vk_layer_settings.hpp
+)
+
+target_include_directories(VulkanSafeStruct PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+
+target_sources(VulkanSafeStruct PRIVATE
+        vulkan/utility/vk_safe_struct.hpp
+        vulkan/utility/vk_safe_struct_utils.hpp
 )
 
 set(CMAKE_FOLDER "${CMAKE_FOLDER}/VulkanUtilityHeaders")
@@ -17,15 +24,18 @@ add_library(Vulkan::UtilityHeaders ALIAS VulkanUtilityHeaders)
 
 # https://cmake.org/cmake/help/latest/release/3.19.html#other
 if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.19")
-	target_sources(VulkanUtilityHeaders PRIVATE
-		vulkan/utility/vk_dispatch_table.h
-		vulkan/vk_enum_string_helper.h
-		vulkan/utility/vk_format_utils.h
-		vulkan/utility/vk_struct_helper.hpp
-	)
+    target_sources(VulkanUtilityHeaders PRIVATE
+        vulkan/vk_enum_string_helper.h
+        vulkan/utility/vk_concurrent_unordered_map.hpp
+        vulkan/utility/vk_dispatch_table.h
+        vulkan/utility/vk_format_utils.h
+        vulkan/utility/vk_small_containers.hpp
+        vulkan/utility/vk_sparse_range_map.hpp
+        vulkan/utility/vk_struct_helper.hpp
+    )
 endif()
 
-target_link_Libraries(VulkanUtilityHeaders INTERFACE Vulkan::Headers)
+target_link_libraries(VulkanUtilityHeaders INTERFACE Vulkan::Headers)
 
 target_include_directories(VulkanUtilityHeaders INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
 

include/vulkan/layer/vk_layer_settings.hpp

@@ -10,52 +10,58 @@
 #pragma once
 
 #include "vk_layer_settings.h"
-#include <vector>
+
 #include <string>
+#include <utility>
+#include <vector>
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<int32_t> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<int64_t> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<uint32_t> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<uint64_t> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<std::string> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<std::string> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<VkuFrameset> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<VkuFrameset> &settingValues);
 
 // Required by vk_safe_struct
 typedef std::pair<uint32_t, uint32_t> VkuCustomSTypeInfo;
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<VkuCustomSTypeInfo> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<VkuCustomSTypeInfo> &settingValues);
 
 // Return the list of Unknown setting in all VkLayerSettingsCreateInfoEXT
 VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t settingsCount, const char **pSettings,

include/vulkan/utility/vk_concurrent_unordered_map.hpp

@@ -0,0 +1,203 @@
+/* Copyright (c) 2015-2017, 2019-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2017, 2019-2024 Valve Corporation
+ * Copyright (c) 2015-2017, 2019-2024 LunarG, Inc.
+ * Modifications Copyright (C) 2022 RasterGrid Kft.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+#include <array>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <unordered_map>
+#include <vector>
+
+namespace vku {
+namespace concurrent {
+// https://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size
+// https://en.wikipedia.org/wiki/False_sharing
+// TODO use C++20 to check for std::hardware_destructive_interference_size feature support.
+constexpr std::size_t get_hardware_destructive_interference_size() { return 64; }
+
+// Limited concurrent unordered_map that supports internally-synchronized
+// insert/erase/access. Splits locking across N buckets and uses shared_mutex
+// for read/write locking. Iterators are not supported. The following
+// operations are supported:
+//
+// insert_or_assign: Insert a new element or update an existing element.
+// insert: Insert a new element and return whether it was inserted.
+// erase: Remove an element.
+// contains: Returns true if the key is in the map.
+// find: Returns != end() if found, value is in ret->second.
+// pop: Erases and returns the erased value if found.
+//
+// find/end: find returns a vaguely iterator-like type that can be compared to
+// end and can use iter->second to retrieve the reference. This is to ease porting
+// for existing code that combines the existence check and lookup in a single
+// operation (and thus a single lock). i.e.:
+//
+//      auto iter = map.find(key);
+//      if (iter != map.end()) {
+//          T t = iter->second;
+//          ...
+//
+// snapshot: Return an array of elements (key, value pairs) that satisfy an optional
+// predicate. This can be used as a substitute for iterators in exceptional cases.
+template <typename Key, typename T, int BUCKETSLOG2 = 2, typename Map = std::unordered_map<Key, T>>
+class unordered_map {
+    // Aliases to avoid excessive typing. We can't easily auto these away because
+    // there are virtual methods in ValidationObject which return lock guards
+    // and those cannot use return type deduction.
+    using ReadLockGuard = std::shared_lock<std::shared_mutex>;
+    using WriteLockGuard = std::unique_lock<std::shared_mutex>;
+
+  public:
+    template <typename... Args>
+    void insert_or_assign(const Key &key, Args &&...args) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        WriteLockGuard lock(locks[h].lock);
+        maps[h][key] = {std::forward<Args>(args)...};
+    }
+
+    template <typename... Args>
+    bool insert(const Key &key, Args &&...args) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        WriteLockGuard lock(locks[h].lock);
+        auto ret = maps[h].emplace(key, std::forward<Args>(args)...);
+        return ret.second;
+    }
+
+    // returns size_type
+    size_t erase(const Key &key) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        WriteLockGuard lock(locks[h].lock);
+        return maps[h].erase(key);
+    }
+
+    bool contains(const Key &key) const {
+        uint32_t h = ConcurrentMapHashObject(key);
+        ReadLockGuard lock(locks[h].lock);
+        return maps[h].count(key) != 0;
+    }
+
+    // type returned by find() and end().
+    class FindResult {
+      public:
+        FindResult(bool a, T b) : result(a, std::move(b)) {}
+
+        // == and != only support comparing against end()
+        bool operator==(const FindResult &other) const {
+            if (result.first == false && other.result.first == false) {
+                return true;
+            }
+            return false;
+        }
+        bool operator!=(const FindResult &other) const { return !(*this == other); }
+
+        // Make -> act kind of like an iterator.
+        std::pair<bool, T> *operator->() { return &result; }
+        const std::pair<bool, T> *operator->() const { return &result; }
+
+      private:
+        // (found, reference to element)
+        std::pair<bool, T> result;
+    };
+
+    // find()/end() return a FindResult containing a copy of the value. For end(),
+    // return a default value.
+    FindResult end() const { return FindResult(false, T()); }
+    FindResult cend() const { return end(); }
+
+    FindResult find(const Key &key) const {
+        uint32_t h = ConcurrentMapHashObject(key);
+        ReadLockGuard lock(locks[h].lock);
+
+        auto itr = maps[h].find(key);
+        const bool found = itr != maps[h].end();
+
+        if (found) {
+            return FindResult(true, itr->second);
+        } else {
+            return end();
+        }
+    }
+
+    FindResult pop(const Key &key) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        WriteLockGuard lock(locks[h].lock);
+
+        auto itr = maps[h].find(key);
+        const bool found = itr != maps[h].end();
+
+        if (found) {
+            auto ret = FindResult(true, itr->second);
+            maps[h].erase(itr);
+            return ret;
+        } else {
+            return end();
+        }
+    }
+
+    std::vector<std::pair<const Key, T>> snapshot(std::function<bool(T)> f = nullptr) const {
+        std::vector<std::pair<const Key, T>> ret;
+        for (int h = 0; h < BUCKETS; ++h) {
+            ReadLockGuard lock(locks[h].lock);
+            for (const auto &j : maps[h]) {
+                if (!f || f(j.second)) {
+                    ret.emplace_back(j.first, j.second);
+                }
+            }
+        }
+        return ret;
+    }
+
+    void clear() {
+        for (int h = 0; h < BUCKETS; ++h) {
+            WriteLockGuard lock(locks[h].lock);
+            maps[h].clear();
+        }
+    }
+
+    size_t size() const {
+        size_t result = 0;
+        for (int h = 0; h < BUCKETS; ++h) {
+            ReadLockGuard lock(locks[h].lock);
+            result += maps[h].size();
+        }
+        return result;
+    }
+
+    bool empty() const {
+        bool result = 0;
+        for (int h = 0; h < BUCKETS; ++h) {
+            ReadLockGuard lock(locks[h].lock);
+            result |= maps[h].empty();
+        }
+        return result;
+    }
+
+  private:
+    static const int BUCKETS = (1 << BUCKETSLOG2);
+
+    Map maps[BUCKETS];
+    struct alignas(get_hardware_destructive_interference_size()) AlignedSharedMutex {
+        std::shared_mutex lock;
+    };
+    mutable std::array<AlignedSharedMutex, BUCKETS> locks;
+
+    uint32_t ConcurrentMapHashObject(const Key &object) const {
+        uint64_t u64 = (uint64_t)(uintptr_t)object;
+        uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64;
+        hash ^= (hash >> BUCKETSLOG2) ^ (hash >> (2 * BUCKETSLOG2));
+        hash &= (BUCKETS - 1);
+        return hash;
+    }
+};
+}  // namespace concurrent
+}  // namespace vku

include/vulkan/utility/vk_dispatch_table.h

@@ -160,7 +160,10 @@ typedef struct VkuInstanceDispatchTable_ {
     PFN_vkCreateScreenSurfaceQNX CreateScreenSurfaceQNX;
     PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX GetPhysicalDeviceScreenPresentationSupportQNX;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM GetPhysicalDeviceExternalTensorPropertiesARM;
     PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV;
+    PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV GetPhysicalDeviceCooperativeVectorPropertiesNV;
+    PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV;
 } VkuInstanceDispatchTable;
 
 // Device function pointer dispatch table
@@ -351,6 +354,25 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetDeviceBufferMemoryRequirements GetDeviceBufferMemoryRequirements;
     PFN_vkGetDeviceImageMemoryRequirements GetDeviceImageMemoryRequirements;
     PFN_vkGetDeviceImageSparseMemoryRequirements GetDeviceImageSparseMemoryRequirements;
+    PFN_vkCmdSetLineStipple CmdSetLineStipple;
+    PFN_vkMapMemory2 MapMemory2;
+    PFN_vkUnmapMemory2 UnmapMemory2;
+    PFN_vkCmdBindIndexBuffer2 CmdBindIndexBuffer2;
+    PFN_vkGetRenderingAreaGranularity GetRenderingAreaGranularity;
+    PFN_vkGetDeviceImageSubresourceLayout GetDeviceImageSubresourceLayout;
+    PFN_vkGetImageSubresourceLayout2 GetImageSubresourceLayout2;
+    PFN_vkCmdPushDescriptorSet CmdPushDescriptorSet;
+    PFN_vkCmdPushDescriptorSetWithTemplate CmdPushDescriptorSetWithTemplate;
+    PFN_vkCmdSetRenderingAttachmentLocations CmdSetRenderingAttachmentLocations;
+    PFN_vkCmdSetRenderingInputAttachmentIndices CmdSetRenderingInputAttachmentIndices;
+    PFN_vkCmdBindDescriptorSets2 CmdBindDescriptorSets2;
+    PFN_vkCmdPushConstants2 CmdPushConstants2;
+    PFN_vkCmdPushDescriptorSet2 CmdPushDescriptorSet2;
+    PFN_vkCmdPushDescriptorSetWithTemplate2 CmdPushDescriptorSetWithTemplate2;
+    PFN_vkCopyMemoryToImage CopyMemoryToImage;
+    PFN_vkCopyImageToMemory CopyImageToMemory;
+    PFN_vkCopyImageToImage CopyImageToImage;
+    PFN_vkTransitionImageLayout TransitionImageLayout;
     PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
     PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
     PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
@@ -421,6 +443,8 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkWaitSemaphoresKHR WaitSemaphoresKHR;
     PFN_vkSignalSemaphoreKHR SignalSemaphoreKHR;
     PFN_vkCmdSetFragmentShadingRateKHR CmdSetFragmentShadingRateKHR;
+    PFN_vkCmdSetRenderingAttachmentLocationsKHR CmdSetRenderingAttachmentLocationsKHR;
+    PFN_vkCmdSetRenderingInputAttachmentIndicesKHR CmdSetRenderingInputAttachmentIndicesKHR;
     PFN_vkWaitForPresentKHR WaitForPresentKHR;
     PFN_vkGetBufferDeviceAddressKHR GetBufferDeviceAddressKHR;
     PFN_vkGetBufferOpaqueCaptureAddressKHR GetBufferOpaqueCaptureAddressKHR;
@@ -443,8 +467,6 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdPipelineBarrier2KHR CmdPipelineBarrier2KHR;
     PFN_vkCmdWriteTimestamp2KHR CmdWriteTimestamp2KHR;
     PFN_vkQueueSubmit2KHR QueueSubmit2KHR;
-    PFN_vkCmdWriteBufferMarker2AMD CmdWriteBufferMarker2AMD;
-    PFN_vkGetQueueCheckpointData2NV GetQueueCheckpointData2NV;
     PFN_vkCmdCopyBuffer2KHR CmdCopyBuffer2KHR;
     PFN_vkCmdCopyImage2KHR CmdCopyImage2KHR;
     PFN_vkCmdCopyBufferToImage2KHR CmdCopyBufferToImage2KHR;
@@ -459,6 +481,13 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR;
     PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR;
     PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR;
+    PFN_vkWaitForPresent2KHR WaitForPresent2KHR;
+    PFN_vkCreatePipelineBinariesKHR CreatePipelineBinariesKHR;
+    PFN_vkDestroyPipelineBinaryKHR DestroyPipelineBinaryKHR;
+    PFN_vkGetPipelineKeyKHR GetPipelineKeyKHR;
+    PFN_vkGetPipelineBinaryDataKHR GetPipelineBinaryDataKHR;
+    PFN_vkReleaseCapturedPipelineDataKHR ReleaseCapturedPipelineDataKHR;
+    PFN_vkCmdSetLineStippleKHR CmdSetLineStippleKHR;
     PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR;
     PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR;
     PFN_vkCmdPushConstants2KHR CmdPushConstants2KHR;
@@ -483,6 +512,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyCuFunctionNVX DestroyCuFunctionNVX;
     PFN_vkCmdCuLaunchKernelNVX CmdCuLaunchKernelNVX;
     PFN_vkGetImageViewHandleNVX GetImageViewHandleNVX;
+    PFN_vkGetImageViewHandle64NVX GetImageViewHandle64NVX;
     PFN_vkGetImageViewAddressNVX GetImageViewAddressNVX;
     PFN_vkCmdDrawIndirectCountAMD CmdDrawIndirectCountAMD;
     PFN_vkCmdDrawIndexedIndirectCountAMD CmdDrawIndexedIndirectCountAMD;
@@ -548,6 +578,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCompileDeferredNV CompileDeferredNV;
     PFN_vkGetMemoryHostPointerPropertiesEXT GetMemoryHostPointerPropertiesEXT;
     PFN_vkCmdWriteBufferMarkerAMD CmdWriteBufferMarkerAMD;
+    PFN_vkCmdWriteBufferMarker2AMD CmdWriteBufferMarker2AMD;
     PFN_vkGetCalibratedTimestampsEXT GetCalibratedTimestampsEXT;
     PFN_vkCmdDrawMeshTasksNV CmdDrawMeshTasksNV;
     PFN_vkCmdDrawMeshTasksIndirectNV CmdDrawMeshTasksIndirectNV;
@@ -556,6 +587,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdSetExclusiveScissorNV CmdSetExclusiveScissorNV;
     PFN_vkCmdSetCheckpointNV CmdSetCheckpointNV;
     PFN_vkGetQueueCheckpointDataNV GetQueueCheckpointDataNV;
+    PFN_vkGetQueueCheckpointData2NV GetQueueCheckpointData2NV;
     PFN_vkInitializePerformanceApiINTEL InitializePerformanceApiINTEL;
     PFN_vkUninitializePerformanceApiINTEL UninitializePerformanceApiINTEL;
     PFN_vkCmdSetPerformanceMarkerINTEL CmdSetPerformanceMarkerINTEL;
@@ -603,12 +635,17 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyPrivateDataSlotEXT DestroyPrivateDataSlotEXT;
     PFN_vkSetPrivateDataEXT SetPrivateDataEXT;
     PFN_vkGetPrivateDataEXT GetPrivateDataEXT;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
     PFN_vkCreateCudaModuleNV CreateCudaModuleNV;
     PFN_vkGetCudaModuleCacheNV GetCudaModuleCacheNV;
     PFN_vkCreateCudaFunctionNV CreateCudaFunctionNV;
     PFN_vkDestroyCudaModuleNV DestroyCudaModuleNV;
     PFN_vkDestroyCudaFunctionNV DestroyCudaFunctionNV;
     PFN_vkCmdCudaLaunchKernelNV CmdCudaLaunchKernelNV;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkCmdDispatchTileQCOM CmdDispatchTileQCOM;
+    PFN_vkCmdBeginPerTileExecutionQCOM CmdBeginPerTileExecutionQCOM;
+    PFN_vkCmdEndPerTileExecutionQCOM CmdEndPerTileExecutionQCOM;
 #ifdef VK_USE_PLATFORM_METAL_EXT
     PFN_vkExportMetalObjectsEXT ExportMetalObjectsEXT;
 #endif  // VK_USE_PLATFORM_METAL_EXT
@@ -676,7 +713,6 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetPipelineIndirectMemoryRequirementsNV GetPipelineIndirectMemoryRequirementsNV;
     PFN_vkCmdUpdatePipelineIndirectBufferNV CmdUpdatePipelineIndirectBufferNV;
     PFN_vkGetPipelineIndirectDeviceAddressNV GetPipelineIndirectDeviceAddressNV;
-    PFN_vkCmdSetTessellationDomainOriginEXT CmdSetTessellationDomainOriginEXT;
     PFN_vkCmdSetDepthClampEnableEXT CmdSetDepthClampEnableEXT;
     PFN_vkCmdSetPolygonModeEXT CmdSetPolygonModeEXT;
     PFN_vkCmdSetRasterizationSamplesEXT CmdSetRasterizationSamplesEXT;
@@ -687,6 +723,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdSetColorBlendEnableEXT CmdSetColorBlendEnableEXT;
     PFN_vkCmdSetColorBlendEquationEXT CmdSetColorBlendEquationEXT;
     PFN_vkCmdSetColorWriteMaskEXT CmdSetColorWriteMaskEXT;
+    PFN_vkCmdSetTessellationDomainOriginEXT CmdSetTessellationDomainOriginEXT;
     PFN_vkCmdSetRasterizationStreamEXT CmdSetRasterizationStreamEXT;
     PFN_vkCmdSetConservativeRasterizationModeEXT CmdSetConservativeRasterizationModeEXT;
     PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT CmdSetExtraPrimitiveOverestimationSizeEXT;
@@ -707,18 +744,32 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdSetShadingRateImageEnableNV CmdSetShadingRateImageEnableNV;
     PFN_vkCmdSetRepresentativeFragmentTestEnableNV CmdSetRepresentativeFragmentTestEnableNV;
     PFN_vkCmdSetCoverageReductionModeNV CmdSetCoverageReductionModeNV;
+    PFN_vkCreateTensorARM CreateTensorARM;
+    PFN_vkDestroyTensorARM DestroyTensorARM;
+    PFN_vkCreateTensorViewARM CreateTensorViewARM;
+    PFN_vkDestroyTensorViewARM DestroyTensorViewARM;
+    PFN_vkGetTensorMemoryRequirementsARM GetTensorMemoryRequirementsARM;
+    PFN_vkBindTensorMemoryARM BindTensorMemoryARM;
+    PFN_vkGetDeviceTensorMemoryRequirementsARM GetDeviceTensorMemoryRequirementsARM;
+    PFN_vkCmdCopyTensorARM CmdCopyTensorARM;
+    PFN_vkGetTensorOpaqueCaptureDescriptorDataARM GetTensorOpaqueCaptureDescriptorDataARM;
+    PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM GetTensorViewOpaqueCaptureDescriptorDataARM;
     PFN_vkGetShaderModuleIdentifierEXT GetShaderModuleIdentifierEXT;
     PFN_vkGetShaderModuleCreateInfoIdentifierEXT GetShaderModuleCreateInfoIdentifierEXT;
     PFN_vkCreateOpticalFlowSessionNV CreateOpticalFlowSessionNV;
     PFN_vkDestroyOpticalFlowSessionNV DestroyOpticalFlowSessionNV;
     PFN_vkBindOpticalFlowSessionImageNV BindOpticalFlowSessionImageNV;
     PFN_vkCmdOpticalFlowExecuteNV CmdOpticalFlowExecuteNV;
+    PFN_vkAntiLagUpdateAMD AntiLagUpdateAMD;
     PFN_vkCreateShadersEXT CreateShadersEXT;
     PFN_vkDestroyShaderEXT DestroyShaderEXT;
     PFN_vkGetShaderBinaryDataEXT GetShaderBinaryDataEXT;
     PFN_vkCmdBindShadersEXT CmdBindShadersEXT;
+    PFN_vkCmdSetDepthClampRangeEXT CmdSetDepthClampRangeEXT;
     PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM;
     PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM;
+    PFN_vkConvertCooperativeVectorMatrixNV ConvertCooperativeVectorMatrixNV;
+    PFN_vkCmdConvertCooperativeVectorMatrixNV CmdConvertCooperativeVectorMatrixNV;
     PFN_vkSetLatencySleepModeNV SetLatencySleepModeNV;
     PFN_vkLatencySleepNV LatencySleepNV;
     PFN_vkSetLatencyMarkerNV SetLatencyMarkerNV;
@@ -728,6 +779,28 @@ typedef struct VkuDeviceDispatchTable_ {
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    PFN_vkCmdBindTileMemoryQCOM CmdBindTileMemoryQCOM;
+    PFN_vkCreateExternalComputeQueueNV CreateExternalComputeQueueNV;
+    PFN_vkDestroyExternalComputeQueueNV DestroyExternalComputeQueueNV;
+    PFN_vkGetExternalComputeQueueDataNV GetExternalComputeQueueDataNV;
+    PFN_vkGetClusterAccelerationStructureBuildSizesNV GetClusterAccelerationStructureBuildSizesNV;
+    PFN_vkCmdBuildClusterAccelerationStructureIndirectNV CmdBuildClusterAccelerationStructureIndirectNV;
+    PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV GetPartitionedAccelerationStructuresBuildSizesNV;
+    PFN_vkCmdBuildPartitionedAccelerationStructuresNV CmdBuildPartitionedAccelerationStructuresNV;
+    PFN_vkGetGeneratedCommandsMemoryRequirementsEXT GetGeneratedCommandsMemoryRequirementsEXT;
+    PFN_vkCmdPreprocessGeneratedCommandsEXT CmdPreprocessGeneratedCommandsEXT;
+    PFN_vkCmdExecuteGeneratedCommandsEXT CmdExecuteGeneratedCommandsEXT;
+    PFN_vkCreateIndirectCommandsLayoutEXT CreateIndirectCommandsLayoutEXT;
+    PFN_vkDestroyIndirectCommandsLayoutEXT DestroyIndirectCommandsLayoutEXT;
+    PFN_vkCreateIndirectExecutionSetEXT CreateIndirectExecutionSetEXT;
+    PFN_vkDestroyIndirectExecutionSetEXT DestroyIndirectExecutionSetEXT;
+    PFN_vkUpdateIndirectExecutionSetPipelineEXT UpdateIndirectExecutionSetPipelineEXT;
+    PFN_vkUpdateIndirectExecutionSetShaderEXT UpdateIndirectExecutionSetShaderEXT;
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    PFN_vkGetMemoryMetalHandleEXT GetMemoryMetalHandleEXT;
+    PFN_vkGetMemoryMetalHandlePropertiesEXT GetMemoryMetalHandlePropertiesEXT;
+#endif  // VK_USE_PLATFORM_METAL_EXT
+    PFN_vkCmdEndRendering2EXT CmdEndRendering2EXT;
     PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR;
     PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR;
     PFN_vkCmdBuildAccelerationStructuresKHR CmdBuildAccelerationStructuresKHR;
@@ -944,6 +1017,25 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->GetDeviceBufferMemoryRequirements = (PFN_vkGetDeviceBufferMemoryRequirements)gdpa(device, "vkGetDeviceBufferMemoryRequirements");
     table->GetDeviceImageMemoryRequirements = (PFN_vkGetDeviceImageMemoryRequirements)gdpa(device, "vkGetDeviceImageMemoryRequirements");
     table->GetDeviceImageSparseMemoryRequirements = (PFN_vkGetDeviceImageSparseMemoryRequirements)gdpa(device, "vkGetDeviceImageSparseMemoryRequirements");
+    table->CmdSetLineStipple = (PFN_vkCmdSetLineStipple)gdpa(device, "vkCmdSetLineStipple");
+    table->MapMemory2 = (PFN_vkMapMemory2)gdpa(device, "vkMapMemory2");
+    table->UnmapMemory2 = (PFN_vkUnmapMemory2)gdpa(device, "vkUnmapMemory2");
+    table->CmdBindIndexBuffer2 = (PFN_vkCmdBindIndexBuffer2)gdpa(device, "vkCmdBindIndexBuffer2");
+    table->GetRenderingAreaGranularity = (PFN_vkGetRenderingAreaGranularity)gdpa(device, "vkGetRenderingAreaGranularity");
+    table->GetDeviceImageSubresourceLayout = (PFN_vkGetDeviceImageSubresourceLayout)gdpa(device, "vkGetDeviceImageSubresourceLayout");
+    table->GetImageSubresourceLayout2 = (PFN_vkGetImageSubresourceLayout2)gdpa(device, "vkGetImageSubresourceLayout2");
+    table->CmdPushDescriptorSet = (PFN_vkCmdPushDescriptorSet)gdpa(device, "vkCmdPushDescriptorSet");
+    table->CmdPushDescriptorSetWithTemplate = (PFN_vkCmdPushDescriptorSetWithTemplate)gdpa(device, "vkCmdPushDescriptorSetWithTemplate");
+    table->CmdSetRenderingAttachmentLocations = (PFN_vkCmdSetRenderingAttachmentLocations)gdpa(device, "vkCmdSetRenderingAttachmentLocations");
+    table->CmdSetRenderingInputAttachmentIndices = (PFN_vkCmdSetRenderingInputAttachmentIndices)gdpa(device, "vkCmdSetRenderingInputAttachmentIndices");
+    table->CmdBindDescriptorSets2 = (PFN_vkCmdBindDescriptorSets2)gdpa(device, "vkCmdBindDescriptorSets2");
+    table->CmdPushConstants2 = (PFN_vkCmdPushConstants2)gdpa(device, "vkCmdPushConstants2");
+    table->CmdPushDescriptorSet2 = (PFN_vkCmdPushDescriptorSet2)gdpa(device, "vkCmdPushDescriptorSet2");
+    table->CmdPushDescriptorSetWithTemplate2 = (PFN_vkCmdPushDescriptorSetWithTemplate2)gdpa(device, "vkCmdPushDescriptorSetWithTemplate2");
+    table->CopyMemoryToImage = (PFN_vkCopyMemoryToImage)gdpa(device, "vkCopyMemoryToImage");
+    table->CopyImageToMemory = (PFN_vkCopyImageToMemory)gdpa(device, "vkCopyImageToMemory");
+    table->CopyImageToImage = (PFN_vkCopyImageToImage)gdpa(device, "vkCopyImageToImage");
+    table->TransitionImageLayout = (PFN_vkTransitionImageLayout)gdpa(device, "vkTransitionImageLayout");
     table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)gdpa(device, "vkCreateSwapchainKHR");
     table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)gdpa(device, "vkDestroySwapchainKHR");
     table->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)gdpa(device, "vkGetSwapchainImagesKHR");
@@ -1014,6 +1106,8 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->WaitSemaphoresKHR = (PFN_vkWaitSemaphoresKHR)gdpa(device, "vkWaitSemaphoresKHR");
     table->SignalSemaphoreKHR = (PFN_vkSignalSemaphoreKHR)gdpa(device, "vkSignalSemaphoreKHR");
     table->CmdSetFragmentShadingRateKHR = (PFN_vkCmdSetFragmentShadingRateKHR)gdpa(device, "vkCmdSetFragmentShadingRateKHR");
+    table->CmdSetRenderingAttachmentLocationsKHR = (PFN_vkCmdSetRenderingAttachmentLocationsKHR)gdpa(device, "vkCmdSetRenderingAttachmentLocationsKHR");
+    table->CmdSetRenderingInputAttachmentIndicesKHR = (PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)gdpa(device, "vkCmdSetRenderingInputAttachmentIndicesKHR");
     table->WaitForPresentKHR = (PFN_vkWaitForPresentKHR)gdpa(device, "vkWaitForPresentKHR");
     table->GetBufferDeviceAddressKHR = (PFN_vkGetBufferDeviceAddressKHR)gdpa(device, "vkGetBufferDeviceAddressKHR");
     table->GetBufferOpaqueCaptureAddressKHR = (PFN_vkGetBufferOpaqueCaptureAddressKHR)gdpa(device, "vkGetBufferOpaqueCaptureAddressKHR");
@@ -1036,8 +1130,6 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CmdPipelineBarrier2KHR = (PFN_vkCmdPipelineBarrier2KHR)gdpa(device, "vkCmdPipelineBarrier2KHR");
     table->CmdWriteTimestamp2KHR = (PFN_vkCmdWriteTimestamp2KHR)gdpa(device, "vkCmdWriteTimestamp2KHR");
     table->QueueSubmit2KHR = (PFN_vkQueueSubmit2KHR)gdpa(device, "vkQueueSubmit2KHR");
-    table->CmdWriteBufferMarker2AMD = (PFN_vkCmdWriteBufferMarker2AMD)gdpa(device, "vkCmdWriteBufferMarker2AMD");
-    table->GetQueueCheckpointData2NV = (PFN_vkGetQueueCheckpointData2NV)gdpa(device, "vkGetQueueCheckpointData2NV");
     table->CmdCopyBuffer2KHR = (PFN_vkCmdCopyBuffer2KHR)gdpa(device, "vkCmdCopyBuffer2KHR");
     table->CmdCopyImage2KHR = (PFN_vkCmdCopyImage2KHR)gdpa(device, "vkCmdCopyImage2KHR");
     table->CmdCopyBufferToImage2KHR = (PFN_vkCmdCopyBufferToImage2KHR)gdpa(device, "vkCmdCopyBufferToImage2KHR");
@@ -1052,6 +1144,13 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->GetRenderingAreaGranularityKHR = (PFN_vkGetRenderingAreaGranularityKHR)gdpa(device, "vkGetRenderingAreaGranularityKHR");
     table->GetDeviceImageSubresourceLayoutKHR = (PFN_vkGetDeviceImageSubresourceLayoutKHR)gdpa(device, "vkGetDeviceImageSubresourceLayoutKHR");
     table->GetImageSubresourceLayout2KHR = (PFN_vkGetImageSubresourceLayout2KHR)gdpa(device, "vkGetImageSubresourceLayout2KHR");
+    table->WaitForPresent2KHR = (PFN_vkWaitForPresent2KHR)gdpa(device, "vkWaitForPresent2KHR");
+    table->CreatePipelineBinariesKHR = (PFN_vkCreatePipelineBinariesKHR)gdpa(device, "vkCreatePipelineBinariesKHR");
+    table->DestroyPipelineBinaryKHR = (PFN_vkDestroyPipelineBinaryKHR)gdpa(device, "vkDestroyPipelineBinaryKHR");
+    table->GetPipelineKeyKHR = (PFN_vkGetPipelineKeyKHR)gdpa(device, "vkGetPipelineKeyKHR");
+    table->GetPipelineBinaryDataKHR = (PFN_vkGetPipelineBinaryDataKHR)gdpa(device, "vkGetPipelineBinaryDataKHR");
+    table->ReleaseCapturedPipelineDataKHR = (PFN_vkReleaseCapturedPipelineDataKHR)gdpa(device, "vkReleaseCapturedPipelineDataKHR");
+    table->CmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)gdpa(device, "vkCmdSetLineStippleKHR");
     table->GetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)gdpa(device, "vkGetCalibratedTimestampsKHR");
     table->CmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)gdpa(device, "vkCmdBindDescriptorSets2KHR");
     table->CmdPushConstants2KHR = (PFN_vkCmdPushConstants2KHR)gdpa(device, "vkCmdPushConstants2KHR");
@@ -1076,6 +1175,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->DestroyCuFunctionNVX = (PFN_vkDestroyCuFunctionNVX)gdpa(device, "vkDestroyCuFunctionNVX");
     table->CmdCuLaunchKernelNVX = (PFN_vkCmdCuLaunchKernelNVX)gdpa(device, "vkCmdCuLaunchKernelNVX");
     table->GetImageViewHandleNVX = (PFN_vkGetImageViewHandleNVX)gdpa(device, "vkGetImageViewHandleNVX");
+    table->GetImageViewHandle64NVX = (PFN_vkGetImageViewHandle64NVX)gdpa(device, "vkGetImageViewHandle64NVX");
     table->GetImageViewAddressNVX = (PFN_vkGetImageViewAddressNVX)gdpa(device, "vkGetImageViewAddressNVX");
     table->CmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD)gdpa(device, "vkCmdDrawIndirectCountAMD");
     table->CmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD)gdpa(device, "vkCmdDrawIndexedIndirectCountAMD");
@@ -1141,6 +1241,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CompileDeferredNV = (PFN_vkCompileDeferredNV)gdpa(device, "vkCompileDeferredNV");
     table->GetMemoryHostPointerPropertiesEXT = (PFN_vkGetMemoryHostPointerPropertiesEXT)gdpa(device, "vkGetMemoryHostPointerPropertiesEXT");
     table->CmdWriteBufferMarkerAMD = (PFN_vkCmdWriteBufferMarkerAMD)gdpa(device, "vkCmdWriteBufferMarkerAMD");
+    table->CmdWriteBufferMarker2AMD = (PFN_vkCmdWriteBufferMarker2AMD)gdpa(device, "vkCmdWriteBufferMarker2AMD");
     table->GetCalibratedTimestampsEXT = (PFN_vkGetCalibratedTimestampsEXT)gdpa(device, "vkGetCalibratedTimestampsEXT");
     table->CmdDrawMeshTasksNV = (PFN_vkCmdDrawMeshTasksNV)gdpa(device, "vkCmdDrawMeshTasksNV");
     table->CmdDrawMeshTasksIndirectNV = (PFN_vkCmdDrawMeshTasksIndirectNV)gdpa(device, "vkCmdDrawMeshTasksIndirectNV");
@@ -1149,6 +1250,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CmdSetExclusiveScissorNV = (PFN_vkCmdSetExclusiveScissorNV)gdpa(device, "vkCmdSetExclusiveScissorNV");
     table->CmdSetCheckpointNV = (PFN_vkCmdSetCheckpointNV)gdpa(device, "vkCmdSetCheckpointNV");
     table->GetQueueCheckpointDataNV = (PFN_vkGetQueueCheckpointDataNV)gdpa(device, "vkGetQueueCheckpointDataNV");
+    table->GetQueueCheckpointData2NV = (PFN_vkGetQueueCheckpointData2NV)gdpa(device, "vkGetQueueCheckpointData2NV");
     table->InitializePerformanceApiINTEL = (PFN_vkInitializePerformanceApiINTEL)gdpa(device, "vkInitializePerformanceApiINTEL");
     table->UninitializePerformanceApiINTEL = (PFN_vkUninitializePerformanceApiINTEL)gdpa(device, "vkUninitializePerformanceApiINTEL");
     table->CmdSetPerformanceMarkerINTEL = (PFN_vkCmdSetPerformanceMarkerINTEL)gdpa(device, "vkCmdSetPerformanceMarkerINTEL");
@@ -1196,12 +1298,17 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->DestroyPrivateDataSlotEXT = (PFN_vkDestroyPrivateDataSlotEXT)gdpa(device, "vkDestroyPrivateDataSlotEXT");
     table->SetPrivateDataEXT = (PFN_vkSetPrivateDataEXT)gdpa(device, "vkSetPrivateDataEXT");
     table->GetPrivateDataEXT = (PFN_vkGetPrivateDataEXT)gdpa(device, "vkGetPrivateDataEXT");
+#ifdef VK_ENABLE_BETA_EXTENSIONS
     table->CreateCudaModuleNV = (PFN_vkCreateCudaModuleNV)gdpa(device, "vkCreateCudaModuleNV");
     table->GetCudaModuleCacheNV = (PFN_vkGetCudaModuleCacheNV)gdpa(device, "vkGetCudaModuleCacheNV");
     table->CreateCudaFunctionNV = (PFN_vkCreateCudaFunctionNV)gdpa(device, "vkCreateCudaFunctionNV");
     table->DestroyCudaModuleNV = (PFN_vkDestroyCudaModuleNV)gdpa(device, "vkDestroyCudaModuleNV");
     table->DestroyCudaFunctionNV = (PFN_vkDestroyCudaFunctionNV)gdpa(device, "vkDestroyCudaFunctionNV");
     table->CmdCudaLaunchKernelNV = (PFN_vkCmdCudaLaunchKernelNV)gdpa(device, "vkCmdCudaLaunchKernelNV");
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+    table->CmdDispatchTileQCOM = (PFN_vkCmdDispatchTileQCOM)gdpa(device, "vkCmdDispatchTileQCOM");
+    table->CmdBeginPerTileExecutionQCOM = (PFN_vkCmdBeginPerTileExecutionQCOM)gdpa(device, "vkCmdBeginPerTileExecutionQCOM");
+    table->CmdEndPerTileExecutionQCOM = (PFN_vkCmdEndPerTileExecutionQCOM)gdpa(device, "vkCmdEndPerTileExecutionQCOM");
 #ifdef VK_USE_PLATFORM_METAL_EXT
     table->ExportMetalObjectsEXT = (PFN_vkExportMetalObjectsEXT)gdpa(device, "vkExportMetalObjectsEXT");
 #endif  // VK_USE_PLATFORM_METAL_EXT
@@ -1269,7 +1376,6 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->GetPipelineIndirectMemoryRequirementsNV = (PFN_vkGetPipelineIndirectMemoryRequirementsNV)gdpa(device, "vkGetPipelineIndirectMemoryRequirementsNV");
     table->CmdUpdatePipelineIndirectBufferNV = (PFN_vkCmdUpdatePipelineIndirectBufferNV)gdpa(device, "vkCmdUpdatePipelineIndirectBufferNV");
     table->GetPipelineIndirectDeviceAddressNV = (PFN_vkGetPipelineIndirectDeviceAddressNV)gdpa(device, "vkGetPipelineIndirectDeviceAddressNV");
-    table->CmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)gdpa(device, "vkCmdSetTessellationDomainOriginEXT");
     table->CmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)gdpa(device, "vkCmdSetDepthClampEnableEXT");
     table->CmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT)gdpa(device, "vkCmdSetPolygonModeEXT");
     table->CmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT)gdpa(device, "vkCmdSetRasterizationSamplesEXT");
@@ -1280,6 +1386,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)gdpa(device, "vkCmdSetColorBlendEnableEXT");
     table->CmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)gdpa(device, "vkCmdSetColorBlendEquationEXT");
     table->CmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)gdpa(device, "vkCmdSetColorWriteMaskEXT");
+    table->CmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)gdpa(device, "vkCmdSetTessellationDomainOriginEXT");
     table->CmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)gdpa(device, "vkCmdSetRasterizationStreamEXT");
     table->CmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)gdpa(device, "vkCmdSetConservativeRasterizationModeEXT");
     table->CmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)gdpa(device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
@@ -1300,18 +1407,32 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CmdSetShadingRateImageEnableNV = (PFN_vkCmdSetShadingRateImageEnableNV)gdpa(device, "vkCmdSetShadingRateImageEnableNV");
     table->CmdSetRepresentativeFragmentTestEnableNV = (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)gdpa(device, "vkCmdSetRepresentativeFragmentTestEnableNV");
     table->CmdSetCoverageReductionModeNV = (PFN_vkCmdSetCoverageReductionModeNV)gdpa(device, "vkCmdSetCoverageReductionModeNV");
+    table->CreateTensorARM = (PFN_vkCreateTensorARM)gdpa(device, "vkCreateTensorARM");
+    table->DestroyTensorARM = (PFN_vkDestroyTensorARM)gdpa(device, "vkDestroyTensorARM");
+    table->CreateTensorViewARM = (PFN_vkCreateTensorViewARM)gdpa(device, "vkCreateTensorViewARM");
+    table->DestroyTensorViewARM = (PFN_vkDestroyTensorViewARM)gdpa(device, "vkDestroyTensorViewARM");
+    table->GetTensorMemoryRequirementsARM = (PFN_vkGetTensorMemoryRequirementsARM)gdpa(device, "vkGetTensorMemoryRequirementsARM");
+    table->BindTensorMemoryARM = (PFN_vkBindTensorMemoryARM)gdpa(device, "vkBindTensorMemoryARM");
+    table->GetDeviceTensorMemoryRequirementsARM = (PFN_vkGetDeviceTensorMemoryRequirementsARM)gdpa(device, "vkGetDeviceTensorMemoryRequirementsARM");
+    table->CmdCopyTensorARM = (PFN_vkCmdCopyTensorARM)gdpa(device, "vkCmdCopyTensorARM");
+    table->GetTensorOpaqueCaptureDescriptorDataARM = (PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)gdpa(device, "vkGetTensorOpaqueCaptureDescriptorDataARM");
+    table->GetTensorViewOpaqueCaptureDescriptorDataARM = (PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)gdpa(device, "vkGetTensorViewOpaqueCaptureDescriptorDataARM");
     table->GetShaderModuleIdentifierEXT = (PFN_vkGetShaderModuleIdentifierEXT)gdpa(device, "vkGetShaderModuleIdentifierEXT");
     table->GetShaderModuleCreateInfoIdentifierEXT = (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)gdpa(device, "vkGetShaderModuleCreateInfoIdentifierEXT");
     table->CreateOpticalFlowSessionNV = (PFN_vkCreateOpticalFlowSessionNV)gdpa(device, "vkCreateOpticalFlowSessionNV");
     table->DestroyOpticalFlowSessionNV = (PFN_vkDestroyOpticalFlowSessionNV)gdpa(device, "vkDestroyOpticalFlowSessionNV");
     table->BindOpticalFlowSessionImageNV = (PFN_vkBindOpticalFlowSessionImageNV)gdpa(device, "vkBindOpticalFlowSessionImageNV");
     table->CmdOpticalFlowExecuteNV = (PFN_vkCmdOpticalFlowExecuteNV)gdpa(device, "vkCmdOpticalFlowExecuteNV");
+    table->AntiLagUpdateAMD = (PFN_vkAntiLagUpdateAMD)gdpa(device, "vkAntiLagUpdateAMD");
     table->CreateShadersEXT = (PFN_vkCreateShadersEXT)gdpa(device, "vkCreateShadersEXT");
     table->DestroyShaderEXT = (PFN_vkDestroyShaderEXT)gdpa(device, "vkDestroyShaderEXT");
     table->GetShaderBinaryDataEXT = (PFN_vkGetShaderBinaryDataEXT)gdpa(device, "vkGetShaderBinaryDataEXT");
     table->CmdBindShadersEXT = (PFN_vkCmdBindShadersEXT)gdpa(device, "vkCmdBindShadersEXT");
+    table->CmdSetDepthClampRangeEXT = (PFN_vkCmdSetDepthClampRangeEXT)gdpa(device, "vkCmdSetDepthClampRangeEXT");
     table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)gdpa(device, "vkGetFramebufferTilePropertiesQCOM");
     table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM)gdpa(device, "vkGetDynamicRenderingTilePropertiesQCOM");
+    table->ConvertCooperativeVectorMatrixNV = (PFN_vkConvertCooperativeVectorMatrixNV)gdpa(device, "vkConvertCooperativeVectorMatrixNV");
+    table->CmdConvertCooperativeVectorMatrixNV = (PFN_vkCmdConvertCooperativeVectorMatrixNV)gdpa(device, "vkCmdConvertCooperativeVectorMatrixNV");
     table->SetLatencySleepModeNV = (PFN_vkSetLatencySleepModeNV)gdpa(device, "vkSetLatencySleepModeNV");
     table->LatencySleepNV = (PFN_vkLatencySleepNV)gdpa(device, "vkLatencySleepNV");
     table->SetLatencyMarkerNV = (PFN_vkSetLatencyMarkerNV)gdpa(device, "vkSetLatencyMarkerNV");
@@ -1321,6 +1442,28 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     table->GetScreenBufferPropertiesQNX = (PFN_vkGetScreenBufferPropertiesQNX)gdpa(device, "vkGetScreenBufferPropertiesQNX");
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    table->CmdBindTileMemoryQCOM = (PFN_vkCmdBindTileMemoryQCOM)gdpa(device, "vkCmdBindTileMemoryQCOM");
+    table->CreateExternalComputeQueueNV = (PFN_vkCreateExternalComputeQueueNV)gdpa(device, "vkCreateExternalComputeQueueNV");
+    table->DestroyExternalComputeQueueNV = (PFN_vkDestroyExternalComputeQueueNV)gdpa(device, "vkDestroyExternalComputeQueueNV");
+    table->GetExternalComputeQueueDataNV = (PFN_vkGetExternalComputeQueueDataNV)gdpa(device, "vkGetExternalComputeQueueDataNV");
+    table->GetClusterAccelerationStructureBuildSizesNV = (PFN_vkGetClusterAccelerationStructureBuildSizesNV)gdpa(device, "vkGetClusterAccelerationStructureBuildSizesNV");
+    table->CmdBuildClusterAccelerationStructureIndirectNV = (PFN_vkCmdBuildClusterAccelerationStructureIndirectNV)gdpa(device, "vkCmdBuildClusterAccelerationStructureIndirectNV");
+    table->GetPartitionedAccelerationStructuresBuildSizesNV = (PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV)gdpa(device, "vkGetPartitionedAccelerationStructuresBuildSizesNV");
+    table->CmdBuildPartitionedAccelerationStructuresNV = (PFN_vkCmdBuildPartitionedAccelerationStructuresNV)gdpa(device, "vkCmdBuildPartitionedAccelerationStructuresNV");
+    table->GetGeneratedCommandsMemoryRequirementsEXT = (PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)gdpa(device, "vkGetGeneratedCommandsMemoryRequirementsEXT");
+    table->CmdPreprocessGeneratedCommandsEXT = (PFN_vkCmdPreprocessGeneratedCommandsEXT)gdpa(device, "vkCmdPreprocessGeneratedCommandsEXT");
+    table->CmdExecuteGeneratedCommandsEXT = (PFN_vkCmdExecuteGeneratedCommandsEXT)gdpa(device, "vkCmdExecuteGeneratedCommandsEXT");
+    table->CreateIndirectCommandsLayoutEXT = (PFN_vkCreateIndirectCommandsLayoutEXT)gdpa(device, "vkCreateIndirectCommandsLayoutEXT");
+    table->DestroyIndirectCommandsLayoutEXT = (PFN_vkDestroyIndirectCommandsLayoutEXT)gdpa(device, "vkDestroyIndirectCommandsLayoutEXT");
+    table->CreateIndirectExecutionSetEXT = (PFN_vkCreateIndirectExecutionSetEXT)gdpa(device, "vkCreateIndirectExecutionSetEXT");
+    table->DestroyIndirectExecutionSetEXT = (PFN_vkDestroyIndirectExecutionSetEXT)gdpa(device, "vkDestroyIndirectExecutionSetEXT");
+    table->UpdateIndirectExecutionSetPipelineEXT = (PFN_vkUpdateIndirectExecutionSetPipelineEXT)gdpa(device, "vkUpdateIndirectExecutionSetPipelineEXT");
+    table->UpdateIndirectExecutionSetShaderEXT = (PFN_vkUpdateIndirectExecutionSetShaderEXT)gdpa(device, "vkUpdateIndirectExecutionSetShaderEXT");
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    table->GetMemoryMetalHandleEXT = (PFN_vkGetMemoryMetalHandleEXT)gdpa(device, "vkGetMemoryMetalHandleEXT");
+    table->GetMemoryMetalHandlePropertiesEXT = (PFN_vkGetMemoryMetalHandlePropertiesEXT)gdpa(device, "vkGetMemoryMetalHandlePropertiesEXT");
+#endif  // VK_USE_PLATFORM_METAL_EXT
+    table->CmdEndRendering2EXT = (PFN_vkCmdEndRendering2EXT)gdpa(device, "vkCmdEndRendering2EXT");
     table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)gdpa(device, "vkCreateAccelerationStructureKHR");
     table->DestroyAccelerationStructureKHR = (PFN_vkDestroyAccelerationStructureKHR)gdpa(device, "vkDestroyAccelerationStructureKHR");
     table->CmdBuildAccelerationStructuresKHR = (PFN_vkCmdBuildAccelerationStructuresKHR)gdpa(device, "vkCmdBuildAccelerationStructuresKHR");
@@ -1487,6 +1630,9 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance
     table->CreateScreenSurfaceQNX = (PFN_vkCreateScreenSurfaceQNX)gipa(instance, "vkCreateScreenSurfaceQNX");
     table->GetPhysicalDeviceScreenPresentationSupportQNX = (PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)gipa(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX");
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    table->GetPhysicalDeviceExternalTensorPropertiesARM = (PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM)gipa(instance, "vkGetPhysicalDeviceExternalTensorPropertiesARM");
     table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)gipa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
+    table->GetPhysicalDeviceCooperativeVectorPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV");
+    table->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV");
 }
 // clang-format on

include/vulkan/utility/vk_safe_struct_utils.hpp

@@ -0,0 +1,126 @@
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2024 Valve Corporation
+ * Copyright (c) 2015-2024 LunarG, Inc.
+ * Copyright (c) 2015-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ ****************************************************************************/
+
+#pragma once
+#include <vulkan/vulkan.h>
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <functional>
+#include <vector>
+
+namespace vku {
+
+// State that elements in a pNext chain may need to be aware of
+struct PNextCopyState {
+    // Custom initialization function. Returns true if the structure passed to init was initialized, false otherwise
+    std::function<bool(VkBaseOutStructure* /* safe_sruct */, const VkBaseOutStructure* /* in_struct */)> init;
+};
+
+void* SafePnextCopy(const void* pNext, PNextCopyState* copy_state = {});
+void FreePnextChain(const void* pNext);
+char* SafeStringCopy(const char* in_string);
+
+template <typename Base, typename T>
+bool AddToPnext(Base& base, const T& data) {
+    assert(base.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    auto** prev = reinterpret_cast<VkBaseOutStructure**>(const_cast<void**>(&base.pNext));
+    auto* current = *prev;
+    while (current) {
+        if (data.sType == current->sType) {
+            return false;
+        }
+        prev = reinterpret_cast<VkBaseOutStructure**>(&current->pNext);
+        current = *prev;
+    }
+    *prev = reinterpret_cast<VkBaseOutStructure*>(SafePnextCopy(&data));
+    return true;
+}
+
+template <typename Base>
+bool RemoveFromPnext(Base& base, VkStructureType t) {
+    assert(base.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    auto** prev = reinterpret_cast<VkBaseOutStructure**>(const_cast<void**>(&base.pNext));
+    auto* current = *prev;
+    while (current) {
+        if (t == current->sType) {
+            *prev = current->pNext;
+            current->pNext = nullptr;
+            FreePnextChain(current);
+            return true;
+        }
+        prev = reinterpret_cast<VkBaseOutStructure**>(&current->pNext);
+        current = *prev;
+    }
+    return false;
+}
+
+template <typename CreateInfo>
+uint32_t FindExtension(CreateInfo& ci, const char* extension_name) {
+    assert(ci.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) {
+        if (strcmp(ci.ppEnabledExtensionNames[i], extension_name) == 0) {
+            return i;
+        }
+    }
+    return ci.enabledExtensionCount;
+}
+
+template <typename CreateInfo>
+bool AddExtension(CreateInfo& ci, const char* extension_name) {
+    assert(ci.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    uint32_t pos = FindExtension(ci, extension_name);
+    if (pos < ci.enabledExtensionCount) {
+        // already present
+        return false;
+    }
+    char** exts = new char*[ci.enabledExtensionCount + 1];
+    if (ci.ppEnabledExtensionNames) {
+        memcpy(exts, ci.ppEnabledExtensionNames, sizeof(char*) * ci.enabledExtensionCount);
+    }
+    exts[ci.enabledExtensionCount] = SafeStringCopy(extension_name);
+    delete[] ci.ppEnabledExtensionNames;
+    ci.ppEnabledExtensionNames = exts;
+    ci.enabledExtensionCount++;
+    return true;
+}
+
+template <typename CreateInfo>
+bool RemoveExtension(CreateInfo& ci, const char* extension_name) {
+    assert(ci.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    uint32_t pos = FindExtension(ci, extension_name);
+    if (pos >= ci.enabledExtensionCount) {
+        // not present
+        return false;
+    }
+    if (ci.enabledExtensionCount == 1) {
+        delete[] ci.ppEnabledExtensionNames[0];
+        delete[] ci.ppEnabledExtensionNames;
+        ci.ppEnabledExtensionNames = nullptr;
+        ci.enabledExtensionCount = 0;
+        return true;
+    }
+    uint32_t out_pos = 0;
+    char** exts = new char*[ci.enabledExtensionCount - 1];
+    for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) {
+        if (i == pos) {
+            delete[] ci.ppEnabledExtensionNames[i];
+        } else {
+            exts[out_pos++] = const_cast<char*>(ci.ppEnabledExtensionNames[i]);
+        }
+    }
+    delete[] ci.ppEnabledExtensionNames;
+    ci.ppEnabledExtensionNames = exts;
+    ci.enabledExtensionCount--;
+    return true;
+}
+
+}  // namespace vku

include/vulkan/utility/vk_small_containers.hpp

@@ -0,0 +1,713 @@
+/* Copyright (c) 2015-2017, 2019-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2017, 2019-2024 Valve Corporation
+ * Copyright (c) 2015-2017, 2019-2024 LunarG, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+#pragma once
+
+#include <cassert>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace vku {
+namespace small {
+
+// A vector class with "small string optimization" -- meaning that the class contains a fixed working store for N elements.
+// Useful in in situations where the needed size is unknown, but the typical size is known  If size increases beyond the
+// fixed capacity, a dynamically allocated working store is created.
+//
+// NOTE: Unlike std::vector which only requires T to be CopyAssignable and CopyConstructable, small::vector requires T to be
+//       MoveAssignable and MoveConstructable
+// NOTE: Unlike std::vector, iterators are invalidated by move assignment between small::vector objects effectively the
+//       "small string" allocation functions as an incompatible allocator.
+template <typename T, size_t N, typename SizeType = uint32_t>
+class vector {
+  public:
+    using value_type = T;
+    using reference = value_type &;
+    using const_reference = const value_type &;
+    using pointer = value_type *;
+    using const_pointer = const value_type *;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+    using size_type = SizeType;
+    static const size_type kSmallCapacity = N;
+    static const size_type kMaxCapacity = std::numeric_limits<size_type>::max();
+    static_assert(N <= kMaxCapacity, "size must be less than size_type::max");
+
+    vector() : size_(0), capacity_(N), working_store_(GetSmallStore()) {}
+
+    vector(std::initializer_list<T> list) : size_(0), capacity_(N), working_store_(GetSmallStore()) { PushBackFrom(list); }
+
+    vector(const vector &other) : size_(0), capacity_(N), working_store_(GetSmallStore()) { PushBackFrom(other); }
+
+    vector(vector &&other) : size_(0), capacity_(N), working_store_(GetSmallStore()) {
+        if (other.large_store_) {
+            MoveLargeStore(other);
+        } else {
+            PushBackFrom(std::move(other));
+        }
+        // Per the spec, when constructing from other, other is guaranteed to be empty after the constructor runs
+        other.clear();
+    }
+
+    vector(size_type size, const value_type &value = value_type()) : size_(0), capacity_(N), working_store_(GetSmallStore()) {
+        reserve(size);
+        auto dest = GetWorkingStore();
+        for (size_type i = 0; i < size; i++) {
+            new (dest) value_type(value);
+            ++dest;
+        }
+        size_ = size;
+    }
+
+    ~vector() { clear(); }
+
+    bool operator==(const vector &rhs) const {
+        if (size_ != rhs.size_) return false;
+        auto value = begin();
+        for (const auto &rh_value : rhs) {
+            if (!(*value == rh_value)) {
+                return false;
+            }
+            ++value;
+        }
+        return true;
+    }
+
+    bool operator!=(const vector &rhs) const { return !(*this == rhs); }
+
+    vector &operator=(const vector &other) {
+        if (this != &other) {
+            if (other.size_ > capacity_) {
+                // Calling reserve would move construct and destroy all current contents, so just clear them before calling
+                // PushBackFrom (which does a reserve vs. the now empty this)
+                clear();
+                PushBackFrom(other);
+            } else {
+                // The copy will fit into the current allocation
+                auto dest = GetWorkingStore();
+                auto source = other.GetWorkingStore();
+
+                const auto overlap = std::min(size_, other.size_);
+                // Copy assign anywhere we have objects in this
+                // Note: usually cheaper than destruct/construct
+                for (size_type i = 0; i < overlap; i++) {
+                    dest[i] = source[i];
+                }
+
+                // Copy construct anywhere we *don't* have objects in this
+                for (size_type i = overlap; i < other.size_; i++) {
+                    new (dest + i) value_type(source[i]);
+                }
+
+                // Any entries in this past other_size_ must be cleaned up...
+                for (size_type i = other.size_; i < size_; i++) {
+                    dest[i].~value_type();
+                }
+                size_ = other.size_;
+            }
+        }
+        return *this;
+    }
+
+    vector &operator=(vector &&other) {
+        if (this != &other) {
+            // Note: move assign doesn't require other to become empty (as does move construction)
+            //       so we'll leave other alone except in the large store case, while moving the object
+            //       *in* the vector from other
+            if (other.large_store_) {
+                // Moving the other large store intact is probably best, even if we have to destroy everything in this.
+                clear();
+                MoveLargeStore(other);
+            } else if (other.size_ > capacity_) {
+                // If we'd have to reallocate, just clean up minimally and copy normally
+                clear();
+                PushBackFrom(std::move(other));
+            } else {
+                // The copy will fit into the current allocation
+                auto dest = GetWorkingStore();
+                auto source = other.GetWorkingStore();
+
+                const auto overlap = std::min(size_, other.size_);
+
+                // Move assign where we have objects in this
+                // Note: usually cheaper than destruct/construct
+                for (size_type i = 0; i < overlap; i++) {
+                    dest[i] = std::move(source[i]);
+                }
+
+                // Move construct where we *don't* have objects in this
+                for (size_type i = overlap; i < other.size_; i++) {
+                    new (dest + i) value_type(std::move(source[i]));
+                }
+
+                // Any entries in this past other_size_ must be cleaned up...
+                for (size_type i = other.size_; i < size_; i++) {
+                    dest[i].~value_type();
+                }
+                size_ = other.size_;
+            }
+        }
+        return *this;
+    }
+
+    reference operator[](size_type pos) {
+        assert(pos < size_);
+        return GetWorkingStore()[pos];
+    }
+    const_reference operator[](size_type pos) const {
+        assert(pos < size_);
+        return GetWorkingStore()[pos];
+    }
+
+    // Like std::vector:: calling front or back on an empty container causes undefined behavior
+    reference front() {
+        assert(size_ > 0);
+        return GetWorkingStore()[0];
+    }
+    const_reference front() const {
+        assert(size_ > 0);
+        return GetWorkingStore()[0];
+    }
+    reference back() {
+        assert(size_ > 0);
+        return GetWorkingStore()[size_ - 1];
+    }
+    const_reference back() const {
+        assert(size_ > 0);
+        return GetWorkingStore()[size_ - 1];
+    }
+
+    bool empty() const { return size_ == 0; }
+
+    template <class... Args>
+    void emplace_back(Args &&...args) {
+        assert(size_ < kMaxCapacity);
+        reserve(size_ + 1);
+        new (GetWorkingStore() + size_) value_type(args...);
+        size_++;
+    }
+
+    // Note: probably should update this to reflect C++23 ranges
+    template <typename Container>
+    void PushBackFrom(const Container &from) {
+        assert(from.size() <= kMaxCapacity);
+        assert(size_ <= kMaxCapacity - from.size());
+        const size_type new_size = size_ + static_cast<size_type>(from.size());
+        reserve(new_size);
+
+        auto dest = GetWorkingStore() + size_;
+        for (const auto &element : from) {
+            new (dest) value_type(element);
+            ++dest;
+        }
+        size_ = new_size;
+    }
+
+    template <typename Container>
+    void PushBackFrom(Container &&from) {
+        assert(from.size() < kMaxCapacity);
+        const size_type new_size = size_ + static_cast<size_type>(from.size());
+        reserve(new_size);
+
+        auto dest = GetWorkingStore() + size_;
+        for (auto &element : from) {
+            new (dest) value_type(std::move(element));
+            ++dest;
+        }
+        size_ = new_size;
+    }
+
+    void reserve(size_type new_cap) {
+        // Since this can't shrink, if we're growing we're newing
+        if (new_cap > capacity_) {
+            assert(capacity_ >= kSmallCapacity);
+            auto new_store = std::unique_ptr<BackingStore[]>(new BackingStore[new_cap]);
+            auto working_store = GetWorkingStore();
+            for (size_type i = 0; i < size_; i++) {
+                new (new_store[i].data) value_type(std::move(working_store[i]));
+                working_store[i].~value_type();
+            }
+            large_store_ = std::move(new_store);
+            assert(new_cap > kSmallCapacity);
+            capacity_ = new_cap;
+        }
+        UpdateWorkingStore();
+        // No shrink here.
+    }
+
+    void clear() {
+        // Keep clear minimal to optimize reset functions for enduring objects
+        // more work is deferred until destruction (freeing of large_store for example)
+        // and we intentionally *aren't* shrinking.  Callers that desire shrink semantics
+        // can call shrink_to_fit.
+        auto working_store = GetWorkingStore();
+        for (size_type i = 0; i < size_; i++) {
+            working_store[i].~value_type();
+        }
+        size_ = 0;
+    }
+
+    void resize(size_type count) {
+        struct ValueInitTag {  // tag to request value-initialization
+            explicit ValueInitTag() = default;
+        };
+        Resize(count, ValueInitTag{});
+    }
+
+    void resize(size_type count, const value_type &value) { Resize(count, value); }
+
+    void shrink_to_fit() {
+        if (size_ == 0) {
+            // shrink resets to small when empty
+            capacity_ = kSmallCapacity;
+            large_store_.reset();
+            UpdateWorkingStore();
+        } else if ((capacity_ > kSmallCapacity) && (capacity_ > size_)) {
+            auto source = GetWorkingStore();
+            // Keep the source from disappearing until the end of the function
+            auto old_store = std::unique_ptr<BackingStore[]>(std::move(large_store_));
+            assert(!large_store_);
+            if (size_ < kSmallCapacity) {
+                capacity_ = kSmallCapacity;
+            } else {
+                large_store_ = std::unique_ptr<BackingStore[]>(new BackingStore[size_]);
+                capacity_ = size_;
+            }
+            UpdateWorkingStore();
+            auto dest = GetWorkingStore();
+            for (size_type i = 0; i < size_; i++) {
+                dest[i] = std::move(source[i]);
+                source[i].~value_type();
+            }
+        }
+    }
+
+    inline iterator begin() { return GetWorkingStore(); }
+    inline const_iterator cbegin() const { return GetWorkingStore(); }
+    inline const_iterator begin() const { return GetWorkingStore(); }
+
+    inline iterator end() { return GetWorkingStore() + size_; }
+    inline const_iterator cend() const { return GetWorkingStore() + size_; }
+    inline const_iterator end() const { return GetWorkingStore() + size_; }
+    inline size_type size() const { return size_; }
+    auto capacity() const { return capacity_; }
+
+    inline pointer data() { return GetWorkingStore(); }
+    inline const_pointer data() const { return GetWorkingStore(); }
+
+  protected:
+    inline const_pointer ComputeWorkingStore() const {
+        assert(large_store_ || (capacity_ == kSmallCapacity));
+
+        const BackingStore *store = large_store_ ? large_store_.get() : small_store_;
+        return &store->object;
+    }
+    inline pointer ComputeWorkingStore() {
+        assert(large_store_ || (capacity_ == kSmallCapacity));
+
+        BackingStore *store = large_store_ ? large_store_.get() : small_store_;
+        return &store->object;
+    }
+
+    void UpdateWorkingStore() { working_store_ = ComputeWorkingStore(); }
+
+    inline const_pointer GetWorkingStore() const {
+        DbgWorkingStoreCheck();
+        return working_store_;
+    }
+    inline pointer GetWorkingStore() {
+        DbgWorkingStoreCheck();
+        return working_store_;
+    }
+
+    inline pointer GetSmallStore() { return &small_store_->object; }
+
+    union BackingStore {
+        BackingStore() {}
+        ~BackingStore() {}
+
+        uint8_t data[sizeof(value_type)];
+        value_type object;
+    };
+    size_type size_;
+    size_type capacity_;
+    BackingStore small_store_[N];
+    std::unique_ptr<BackingStore[]> large_store_;
+    value_type *working_store_;
+
+#ifndef NDEBUG
+    void DbgWorkingStoreCheck() const { assert(ComputeWorkingStore() == working_store_); }
+#else
+    void DbgWorkingStoreCheck() const {}
+#endif
+
+  private:
+    void MoveLargeStore(vector &other) {
+        assert(other.large_store_);
+        assert(other.capacity_ > kSmallCapacity);
+        // In move operations, from a small vector with a large store, we can move from it
+        large_store_ = std::move(other.large_store_);
+        capacity_ = other.capacity_;
+        size_ = other.size_;
+        UpdateWorkingStore();
+
+        // We've stolen other's large store, must leave it in a valid state
+        other.size_ = 0;
+        other.capacity_ = kSmallCapacity;
+        other.UpdateWorkingStore();
+    }
+
+    template <typename T2>
+    void Resize(size_type new_size, const T2 &value) {
+        if (new_size < size_) {
+            auto working_store = GetWorkingStore();
+            for (size_type i = new_size; i < size_; i++) {
+                working_store[i].~value_type();
+            }
+            size_ = new_size;
+        } else if (new_size > size_) {
+            reserve(new_size);
+            // if T2 != T and T is not DefaultInsertable, new values will be undefined
+            if constexpr (std::is_same_v<T2, T> || std::is_default_constructible_v<T>) {
+                for (size_type i = size_; i < new_size; ++i) {
+                    if constexpr (std::is_same_v<T2, T>) {
+                        emplace_back(value_type(value));
+                    } else if constexpr (std::is_default_constructible_v<T>) {
+                        emplace_back(value_type());
+                    }
+                }
+                assert(size() == new_size);
+            } else {
+                size_ = new_size;
+            }
+        }
+    }
+};
+
+// This is a wrapper around unordered_map that optimizes for the common case
+// of only containing a small number of elements. The first N elements are stored
+// inline in the object and don't require hashing or memory (de)allocation.
+
+template <typename Key, typename value_type, typename inner_container_type, typename value_type_helper, int N>
+class container_base {
+  protected:
+    bool small_data_allocated[N];
+    value_type small_data[N];
+
+    inner_container_type inner_cont;
+
+    value_type_helper helper;
+
+  public:
+    container_base() {
+        for (int i = 0; i < N; ++i) {
+            small_data_allocated[i] = false;
+        }
+    }
+
+    class iterator {
+        typedef typename inner_container_type::iterator inner_iterator;
+        friend class container_base<Key, value_type, inner_container_type, value_type_helper, N>;
+
+        container_base<Key, value_type, inner_container_type, value_type_helper, N> *parent;
+        int index;
+        inner_iterator it;
+
+      public:
+        iterator() {}
+
+        iterator operator++() {
+            if (index < N) {
+                index++;
+                while (index < N && !parent->small_data_allocated[index]) {
+                    index++;
+                }
+                if (index < N) {
+                    return *this;
+                }
+                it = parent->inner_cont.begin();
+                return *this;
+            }
+            ++it;
+            return *this;
+        }
+
+        bool operator==(const iterator &other) const {
+            if ((index < N) != (other.index < N)) {
+                return false;
+            }
+            if (index < N) {
+                return (index == other.index);
+            }
+            return it == other.it;
+        }
+
+        bool operator!=(const iterator &other) const { return !(*this == other); }
+
+        value_type &operator*() const {
+            if (index < N) {
+                return parent->small_data[index];
+            }
+            return *it;
+        }
+        value_type *operator->() const {
+            if (index < N) {
+                return &parent->small_data[index];
+            }
+            return &*it;
+        }
+    };
+
+    class const_iterator {
+        typedef typename inner_container_type::const_iterator inner_iterator;
+        friend class container_base<Key, value_type, inner_container_type, value_type_helper, N>;
+
+        const container_base<Key, value_type, inner_container_type, value_type_helper, N> *parent;
+        int index;
+        inner_iterator it;
+
+      public:
+        const_iterator() {}
+
+        const_iterator operator++() {
+            if (index < N) {
+                index++;
+                while (index < N && !parent->small_data_allocated[index]) {
+                    index++;
+                }
+                if (index < N) {
+                    return *this;
+                }
+                it = parent->inner_cont.begin();
+                return *this;
+            }
+            ++it;
+            return *this;
+        }
+
+        bool operator==(const const_iterator &other) const {
+            if ((index < N) != (other.index < N)) {
+                return false;
+            }
+            if (index < N) {
+                return (index == other.index);
+            }
+            return it == other.it;
+        }
+
+        bool operator!=(const const_iterator &other) const { return !(*this == other); }
+
+        const value_type &operator*() const {
+            if (index < N) {
+                return parent->small_data[index];
+            }
+            return *it;
+        }
+        const value_type *operator->() const {
+            if (index < N) {
+                return &parent->small_data[index];
+            }
+            return &*it;
+        }
+    };
+
+    iterator begin() {
+        iterator it;
+        it.parent = this;
+        // If index 0 is allocated, return it, otherwise use operator++ to find the first
+        // allocated element.
+        it.index = 0;
+        if (small_data_allocated[0]) {
+            return it;
+        }
+        ++it;
+        return it;
+    }
+
+    iterator end() {
+        iterator it;
+        it.parent = this;
+        it.index = N;
+        it.it = inner_cont.end();
+        return it;
+    }
+
+    const_iterator begin() const {
+        const_iterator it;
+        it.parent = this;
+        // If index 0 is allocated, return it, otherwise use operator++ to find the first
+        // allocated element.
+        it.index = 0;
+        if (small_data_allocated[0]) {
+            return it;
+        }
+        ++it;
+        return it;
+    }
+
+    const_iterator end() const {
+        const_iterator it;
+        it.parent = this;
+        it.index = N;
+        it.it = inner_cont.end();
+        return it;
+    }
+
+    bool contains(const Key &key) const {
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i] && helper.compare_equal(small_data[i], key)) {
+                return true;
+            }
+        }
+        // check size() first to avoid hashing key unnecessarily.
+        if (inner_cont.size() == 0) {
+            return false;
+        }
+        return inner_cont.find(key) != inner_cont.end();
+    }
+
+    typename inner_container_type::size_type count(const Key &key) const { return contains(key) ? 1 : 0; }
+
+    std::pair<iterator, bool> insert(const value_type &value) {
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i] && helper.compare_equal(small_data[i], value)) {
+                iterator it;
+                it.parent = this;
+                it.index = i;
+                return std::make_pair(it, false);
+            }
+        }
+        // check size() first to avoid hashing key unnecessarily.
+        auto iter = inner_cont.size() > 0 ? inner_cont.find(helper.get_key(value)) : inner_cont.end();
+        if (iter != inner_cont.end()) {
+            iterator it;
+            it.parent = this;
+            it.index = N;
+            it.it = iter;
+            return std::make_pair(it, false);
+        } else {
+            for (int i = 0; i < N; ++i) {
+                if (!small_data_allocated[i]) {
+                    small_data_allocated[i] = true;
+                    helper.assign(small_data[i], value);
+                    iterator it;
+                    it.parent = this;
+                    it.index = i;
+                    return std::make_pair(it, true);
+                }
+            }
+            iter = inner_cont.insert(value).first;
+            iterator it;
+            it.parent = this;
+            it.index = N;
+            it.it = iter;
+            return std::make_pair(it, true);
+        }
+    }
+
+    typename inner_container_type::size_type erase(const Key &key) {
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i] && helper.compare_equal(small_data[i], key)) {
+                small_data_allocated[i] = false;
+                return 1;
+            }
+        }
+        return inner_cont.erase(key);
+    }
+
+    typename inner_container_type::size_type size() const {
+        auto size = inner_cont.size();
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i]) {
+                size++;
+            }
+        }
+        return size;
+    }
+
+    bool empty() const {
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i]) {
+                return false;
+            }
+        }
+        return inner_cont.size() == 0;
+    }
+
+    void clear() {
+        for (int i = 0; i < N; ++i) {
+            small_data_allocated[i] = false;
+        }
+        inner_cont.clear();
+    }
+};
+
+// Helper function objects to compare/assign/get keys in small_unordered_set/map.
+// This helps to abstract away whether value_type is a Key or a pair<Key, T>.
+template <typename MapType>
+class value_type_helper_map {
+    using PairType = typename MapType::value_type;
+    using Key = typename std::remove_const<typename PairType::first_type>::type;
+
+  public:
+    bool compare_equal(const PairType &lhs, const Key &rhs) const { return lhs.first == rhs; }
+    bool compare_equal(const PairType &lhs, const PairType &rhs) const { return lhs.first == rhs.first; }
+
+    void assign(PairType &lhs, const PairType &rhs) const {
+        // While the const_cast may be unsatisfactory, we are using small_data as
+        // stand-in for placement new and a small-block allocator, so the const_cast
+        // is minimal, contained, valid, and allows operators * and -> to avoid copies
+        const_cast<Key &>(lhs.first) = rhs.first;
+        lhs.second = rhs.second;
+    }
+
+    Key get_key(const PairType &value) const { return value.first; }
+};
+
+template <typename Key>
+class value_type_helper_set {
+  public:
+    bool compare_equal(const Key &lhs, const Key &rhs) const { return lhs == rhs; }
+
+    void assign(Key &lhs, const Key &rhs) const { lhs = rhs; }
+
+    Key get_key(const Key &value) const { return value; }
+};
+
+template <typename Key, typename T, int N = 1, typename Map = std::unordered_map<Key, T>>
+class unordered_map : public container_base<Key, typename Map::value_type, Map, value_type_helper_map<Map>, N> {
+  public:
+    T &operator[](const Key &key) {
+        for (int i = 0; i < N; ++i) {
+            if (this->small_data_allocated[i] && this->helper.compare_equal(this->small_data[i], key)) {
+                return this->small_data[i].second;
+            }
+        }
+        auto iter = this->inner_cont.find(key);
+        if (iter != this->inner_cont.end()) {
+            return iter->second;
+        } else {
+            for (int i = 0; i < N; ++i) {
+                if (!this->small_data_allocated[i]) {
+                    this->small_data_allocated[i] = true;
+                    this->helper.assign(this->small_data[i], {key, T()});
+
+                    return this->small_data[i].second;
+                }
+            }
+            return this->inner_cont[key];
+        }
+    }
+};
+
+template <typename Key, int N = 1, typename Set = std::unordered_set<Key>>
+class unordered_set : public container_base<Key, Key, Set, value_type_helper_set<Key>, N> {};
+
+}  // namespace small
+}  // namespace vku

include/vulkan/utility/vk_struct_helper.hpp

@@ -232,6 +232,56 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance4Features
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance4Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; }
 template <> inline VkStructureType GetSType<VkDeviceBufferMemoryRequirements>() { return VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS; }
 template <> inline VkStructureType GetSType<VkDeviceImageMemoryRequirements>() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVulkan14Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVulkan14Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkDeviceQueueGlobalPriorityCreateInfo>() { return VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceGlobalPriorityQueryFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; }
+template <> inline VkStructureType GetSType<VkQueueFamilyGlobalPriorityProperties>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupRotateFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderFloatControls2Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderExpectAssumeFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPipelineRasterizationLineStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPipelineVertexInputDivisorStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceIndexTypeUint8Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; }
+template <> inline VkStructureType GetSType<VkMemoryMapInfo>() { return VK_STRUCTURE_TYPE_MEMORY_MAP_INFO; }
+template <> inline VkStructureType GetSType<VkMemoryUnmapInfo>() { return VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkRenderingAreaInfo>() { return VK_STRUCTURE_TYPE_RENDERING_AREA_INFO; }
+template <> inline VkStructureType GetSType<VkImageSubresource2>() { return VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2; }
+template <> inline VkStructureType GetSType<VkDeviceImageSubresourceInfo>() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO; }
+template <> inline VkStructureType GetSType<VkSubresourceLayout2>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; }
+template <> inline VkStructureType GetSType<VkPipelineCreateFlags2CreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkBufferUsageFlags2CreateInfo>() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePushDescriptorProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDynamicRenderingLocalReadFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; }
+template <> inline VkStructureType GetSType<VkRenderingAttachmentLocationInfo>() { return VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO; }
+template <> inline VkStructureType GetSType<VkRenderingInputAttachmentIndexInfo>() { return VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkBindMemoryStatus>() { return VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS; }
+template <> inline VkStructureType GetSType<VkBindDescriptorSetsInfo>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO; }
+template <> inline VkStructureType GetSType<VkPushConstantsInfo>() { return VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO; }
+template <> inline VkStructureType GetSType<VkPushDescriptorSetInfo>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO; }
+template <> inline VkStructureType GetSType<VkPushDescriptorSetWithTemplateInfo>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineProtectedAccessFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineRobustnessFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineRobustnessProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPipelineRobustnessCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkMemoryToImageCopy>() { return VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY; }
+template <> inline VkStructureType GetSType<VkImageToMemoryCopy>() { return VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY; }
+template <> inline VkStructureType GetSType<VkCopyMemoryToImageInfo>() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO; }
+template <> inline VkStructureType GetSType<VkCopyImageToMemoryInfo>() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO; }
+template <> inline VkStructureType GetSType<VkCopyImageToImageInfo>() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO; }
+template <> inline VkStructureType GetSType<VkHostImageLayoutTransitionInfo>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO; }
+template <> inline VkStructureType GetSType<VkSubresourceHostMemcpySize>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; }
+template <> inline VkStructureType GetSType<VkHostImageCopyDevicePerformanceQuery>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY; }
 template <> inline VkStructureType GetSType<VkSwapchainCreateInfoKHR>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPresentInfoKHR>() { return VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkImageSwapchainCreateInfoKHR>() { return VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; }
@@ -312,10 +362,6 @@ template <> inline VkStructureType GetSType<VkVideoDecodeH264SessionParametersAd
 template <> inline VkStructureType GetSType<VkVideoDecodeH264SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH264PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH264DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkRenderingFragmentShadingRateAttachmentInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkRenderingFragmentDensityMapAttachmentInfoEXT>() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkAttachmentSampleCountInfoAMD>() { return VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; }
-template <> inline VkStructureType GetSType<VkMultiviewPerViewAttributesInfoNVX>() { return VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 template <> inline VkStructureType GetSType<VkImportMemoryWin32HandleInfoKHR>() { return VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkExportMemoryWin32HandleInfoKHR>() { return VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; }
@@ -334,7 +380,6 @@ template <> inline VkStructureType GetSType<VkSemaphoreGetWin32HandleInfoKHR>()
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 template <> inline VkStructureType GetSType<VkImportSemaphoreFdInfoKHR>() { return VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkSemaphoreGetFdInfoKHR>() { return VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDevicePushDescriptorPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPresentRegionsKHR>() { return VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR; }
 template <> inline VkStructureType GetSType<VkSharedPresentSurfaceCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -359,6 +404,7 @@ template <> inline VkStructureType GetSType<VkDisplayPlaneProperties2KHR>() { re
 template <> inline VkStructureType GetSType<VkDisplayModeProperties2KHR>() { return VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR; }
 template <> inline VkStructureType GetSType<VkDisplayPlaneInfo2KHR>() { return VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR; }
 template <> inline VkStructureType GetSType<VkDisplayPlaneCapabilities2KHR>() { return VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderBfloat16FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 template <> inline VkStructureType GetSType<VkPhysicalDevicePortabilitySubsetFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePortabilitySubsetPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; }
@@ -370,14 +416,13 @@ template <> inline VkStructureType GetSType<VkVideoDecodeH265SessionParametersAd
 template <> inline VkStructureType GetSType<VkVideoDecodeH265SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH265PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH265DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkDeviceQueueGlobalPriorityCreateInfoKHR>() { return VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkQueueFamilyGlobalPriorityPropertiesKHR>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkFragmentShadingRateAttachmentInfoKHR>() { return VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPipelineFragmentShadingRateStateCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRateKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; }
+template <> inline VkStructureType GetSType<VkRenderingFragmentShadingRateAttachmentInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderQuadControlFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkSurfaceProtectedCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePresentWaitFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; }
@@ -386,8 +431,6 @@ template <> inline VkStructureType GetSType<VkPipelineExecutablePropertiesKHR>()
 template <> inline VkStructureType GetSType<VkPipelineExecutableInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPipelineExecutableStatisticKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR; }
 template <> inline VkStructureType GetSType<VkPipelineExecutableInternalRepresentationKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; }
-template <> inline VkStructureType GetSType<VkMemoryMapInfoKHR>() { return VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkMemoryUnmapInfoKHR>() { return VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPipelineLibraryCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPresentIdKHR>() { return VK_STRUCTURE_TYPE_PRESENT_ID_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePresentIdFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; }
@@ -402,40 +445,89 @@ template <> inline VkStructureType GetSType<VkVideoEncodeQualityLevelPropertiesK
 template <> inline VkStructureType GetSType<VkVideoEncodeQualityLevelInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoEncodeSessionParametersGetInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoEncodeSessionParametersFeedbackInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkQueueFamilyCheckpointProperties2NV>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; }
-template <> inline VkStructureType GetSType<VkCheckpointData2NV>() { return VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR; }
-template <> inline VkStructureType GetSType<VkRenderingAreaInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkImageSubresource2KHR>() { return VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR; }
-template <> inline VkStructureType GetSType<VkDeviceImageSubresourceInfoKHR>() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkSubresourceLayout2KHR>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR; }
-template <> inline VkStructureType GetSType<VkPipelineCreateFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkBufferUsageFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesPresentId2KHR>() { return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; }
+template <> inline VkStructureType GetSType<VkPresentId2KHR>() { return VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePresentId2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesPresentWait2KHR>() { return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePresentWait2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPresentWait2InfoKHR>() { return VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkDevicePipelineBinaryInternalCacheControlKHR>() { return VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryKeyKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkReleaseCapturedPipelineDataInfoKHR>() { return VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryDataInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryHandlesInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1ProfileInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1CapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1CapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1QualityLevelPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1SessionCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1ProfileInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1GopRemainingFrameInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlLayerInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeVP9ProfileInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeVP9CapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeVP9PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkVideoInlineQueryInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; }
-template <> inline VkStructureType GetSType<VkPipelineVertexInputDivisorStateCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkAttachmentFeedbackLoopInfoEXT>() { return VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkCalibratedTimestampInfoKHR>() { return VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR; }
-template <> inline VkStructureType GetSType<VkBindMemoryStatusKHR>() { return VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR; }
-template <> inline VkStructureType GetSType<VkBindDescriptorSetsInfoKHR>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPushConstantsInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPushDescriptorSetInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPushDescriptorSetWithTemplateInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkSetDescriptorBufferOffsetsInfoEXT>() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoFormatQuantizationMapPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeH264QuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeH265QuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoFormatH265QuantizationMapPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoFormatAV1QuantizationMapPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiPropertiesListKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance8FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkMemoryBarrierAccessFlags3KHR>() { return VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance9FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance9PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkQueueFamilyOwnershipTransferPropertiesKHR>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeH264InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeH265InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkDebugReportCallbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineRasterizationStateRasterizationOrderAMD>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; }
 template <> inline VkStructureType GetSType<VkDebugMarkerObjectNameInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; }
@@ -448,6 +540,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceTransformFeedbackFea
 template <> inline VkStructureType GetSType<VkPhysicalDeviceTransformFeedbackPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineRasterizationStateStreamCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkCuModuleCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX; }
+template <> inline VkStructureType GetSType<VkCuModuleTexturingModeCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX; }
 template <> inline VkStructureType GetSType<VkCuFunctionCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX; }
 template <> inline VkStructureType GetSType<VkCuLaunchInfoNVX>() { return VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX; }
 template <> inline VkStructureType GetSType<VkImageViewHandleInfoNVX>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX; }
@@ -470,9 +563,6 @@ template <> inline VkStructureType GetSType<VkViSurfaceCreateInfoNN>() { return
 #endif  // VK_USE_PLATFORM_VI_NN
 template <> inline VkStructureType GetSType<VkImageViewASTCDecodeModeEXT>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceASTCDecodeFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineRobustnessPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT; }
-template <> inline VkStructureType GetSType<VkPipelineRobustnessCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkConditionalRenderingBeginInfoEXT>() { return VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceConditionalRenderingFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkCommandBufferInheritanceConditionalRenderingInfoEXT>() { return VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; }
@@ -484,6 +574,7 @@ template <> inline VkStructureType GetSType<VkDisplayEventInfoEXT>() { return VK
 template <> inline VkStructureType GetSType<VkSwapchainCounterCreateInfoEXT>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPresentTimesInfoGOOGLE>() { return VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; }
+template <> inline VkStructureType GetSType<VkMultiviewPerViewAttributesInfoNVX>() { return VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; }
 template <> inline VkStructureType GetSType<VkPipelineViewportSwizzleStateCreateInfoNV>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDiscardRectanglePropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineDiscardRectangleStateCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; }
@@ -520,6 +611,7 @@ template <> inline VkStructureType GetSType<VkExecutionGraphPipelineScratchSizeA
 template <> inline VkStructureType GetSType<VkExecutionGraphPipelineCreateInfoAMDX>() { return VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX; }
 template <> inline VkStructureType GetSType<VkPipelineShaderStageNodeCreateInfoAMDX>() { return VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX; }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+template <> inline VkStructureType GetSType<VkAttachmentSampleCountInfoAMD>() { return VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; }
 template <> inline VkStructureType GetSType<VkSampleLocationsInfoEXT>() { return VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkRenderPassSampleLocationsBeginInfoEXT>() { return VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineSampleLocationsStateCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; }
@@ -569,7 +661,6 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivis
 #ifdef VK_USE_PLATFORM_GGP
 template <> inline VkStructureType GetSType<VkPresentFrameTokenGGP>() { return VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP; }
 #endif  // VK_USE_PLATFORM_GGP
-template <> inline VkStructureType GetSType<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMeshShaderFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMeshShaderPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderImageFootprintFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; }
@@ -577,6 +668,8 @@ template <> inline VkStructureType GetSType<VkPipelineViewportExclusiveScissorSt
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExclusiveScissorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkQueueFamilyCheckpointPropertiesNV>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkCheckpointDataNV>() { return VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV; }
+template <> inline VkStructureType GetSType<VkQueueFamilyCheckpointProperties2NV>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; }
+template <> inline VkStructureType GetSType<VkCheckpointData2NV>() { return VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; }
 template <> inline VkStructureType GetSType<VkInitializePerformanceApiInfoINTEL>() { return VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL; }
 template <> inline VkStructureType GetSType<VkQueryPoolPerformanceQueryCreateInfoINTEL>() { return VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; }
@@ -596,6 +689,7 @@ template <> inline VkStructureType GetSType<VkMetalSurfaceCreateInfoEXT>() { ret
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkRenderPassFragmentDensityMapCreateInfoEXT>() { return VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkRenderingFragmentDensityMapAttachmentInfoEXT>() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderCoreProperties2AMD>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCoherentMemoryFeaturesAMD>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; }
@@ -623,22 +717,11 @@ template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesFullScreenExclu
 template <> inline VkStructureType GetSType<VkSurfaceFullScreenExclusiveWin32InfoEXT>() { return VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 template <> inline VkStructureType GetSType<VkHeadlessSurfaceCreateInfoEXT>() { return VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT; }
-template <> inline VkStructureType GetSType<VkPipelineRasterizationLineStateCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT; }
-template <> inline VkStructureType GetSType<VkMemoryToImageCopyEXT>() { return VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT; }
-template <> inline VkStructureType GetSType<VkImageToMemoryCopyEXT>() { return VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT; }
-template <> inline VkStructureType GetSType<VkCopyMemoryToImageInfoEXT>() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkCopyImageToMemoryInfoEXT>() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkCopyImageToImageInfoEXT>() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkHostImageLayoutTransitionInfoEXT>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkSubresourceHostMemcpySizeEXT>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT; }
-template <> inline VkStructureType GetSType<VkHostImageCopyDevicePerformanceQueryEXT>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; }
+template <> inline VkStructureType GetSType<VkMemoryMapPlacedInfoEXT>() { return VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkSurfacePresentModeEXT>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT; }
 template <> inline VkStructureType GetSType<VkSurfacePresentScalingCapabilitiesEXT>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; }
@@ -668,8 +751,6 @@ template <> inline VkStructureType GetSType<VkDepthBiasRepresentationInfoEXT>()
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkDeviceMemoryReportCallbackDataEXT>() { return VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT; }
 template <> inline VkStructureType GetSType<VkDeviceDeviceMemoryReportCreateInfoEXT>() { return VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2PropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkSamplerCustomBorderColorCreateInfoEXT>() { return VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCustomBorderColorPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCustomBorderColorFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; }
@@ -678,11 +759,19 @@ template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesPresentBarrierN
 template <> inline VkStructureType GetSType<VkSwapchainPresentBarrierCreateInfoNV>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDiagnosticsConfigFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkDeviceDiagnosticsConfigCreateInfoNV>() { return VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
 template <> inline VkStructureType GetSType<VkCudaModuleCreateInfoNV>() { return VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkCudaFunctionCreateInfoNV>() { return VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkCudaLaunchInfoNV>() { return VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCudaKernelLaunchFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCudaKernelLaunchPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTileShadingFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTileShadingPropertiesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; }
+template <> inline VkStructureType GetSType<VkRenderPassTileShadingCreateInfoQCOM>() { return VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkPerTileBeginInfoQCOM>() { return VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkPerTileEndInfoQCOM>() { return VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkDispatchTileInfoQCOM>() { return VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM; }
 template <> inline VkStructureType GetSType<VkQueryLowLatencySupportNV>() { return VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; }
 #ifdef VK_USE_PLATFORM_METAL_EXT
 template <> inline VkStructureType GetSType<VkExportMetalObjectCreateInfoEXT>() { return VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; }
@@ -749,6 +838,7 @@ template <> inline VkStructureType GetSType<VkDeviceAddressBindingCallbackDataEX
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClipControlFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineViewportDepthClipControlCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; }
 #ifdef VK_USE_PLATFORM_FUCHSIA
 template <> inline VkStructureType GetSType<VkImportMemoryZirconHandleInfoFUCHSIA>() { return VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; }
 template <> inline VkStructureType GetSType<VkMemoryZirconHandlePropertiesFUCHSIA>() { return VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; }
@@ -823,16 +913,15 @@ template <> inline VkStructureType GetSType<VkImageViewSlicedCreateInfoEXT>() {
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; }
 template <> inline VkStructureType GetSType<VkDescriptorSetBindingReferenceVALVE>() { return VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; }
 template <> inline VkStructureType GetSType<VkDescriptorSetLayoutHostMappingInfoVALVE>() { return VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRenderPassStripedFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRenderPassStripedPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; }
 template <> inline VkStructureType GetSType<VkRenderPassStripeInfoARM>() { return VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM; }
 template <> inline VkStructureType GetSType<VkRenderPassStripeBeginInfoARM>() { return VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; }
 template <> inline VkStructureType GetSType<VkRenderPassStripeSubmitInfoARM>() { return VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM; }
-template <> inline VkStructureType GetSType<VkSubpassFragmentDensityMapOffsetEndInfoQCOM>() { return VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; }
+template <> inline VkStructureType GetSType<VkRenderPassFragmentDensityMapOffsetEndInfoEXT>() { return VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMemoryDecompressionFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; }
@@ -840,6 +929,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceMemoryDecompressionP
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkComputePipelineIndirectBufferInfoNV>() { return VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPipelineIndirectDeviceAddressInfoNV>() { return VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryLinearSweptSpheresDataNV>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV; }
+template <> inline VkStructureType GetSType<VkAccelerationStructureGeometrySpheresDataNV>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLinearColorAttachmentFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkImageViewSampleWeightCreateInfoQCOM>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; }
@@ -856,6 +948,30 @@ template <> inline VkStructureType GetSType<VkRenderPassCreationFeedbackCreateIn
 template <> inline VkStructureType GetSType<VkRenderPassSubpassFeedbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkDirectDriverLoadingInfoLUNARG>() { return VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG; }
 template <> inline VkStructureType GetSType<VkDirectDriverLoadingListLUNARG>() { return VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG; }
+template <> inline VkStructureType GetSType<VkTensorDescriptionARM>() { return VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM; }
+template <> inline VkStructureType GetSType<VkTensorCreateInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkTensorViewCreateInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkTensorMemoryRequirementsInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkBindTensorMemoryInfoARM>() { return VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkWriteDescriptorSetTensorARM>() { return VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM; }
+template <> inline VkStructureType GetSType<VkTensorFormatPropertiesARM>() { return VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTensorPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; }
+template <> inline VkStructureType GetSType<VkTensorMemoryBarrierARM>() { return VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM; }
+template <> inline VkStructureType GetSType<VkTensorDependencyInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTensorFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; }
+template <> inline VkStructureType GetSType<VkDeviceTensorMemoryRequirementsARM>() { return VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM; }
+template <> inline VkStructureType GetSType<VkTensorCopyARM>() { return VK_STRUCTURE_TYPE_TENSOR_COPY_ARM; }
+template <> inline VkStructureType GetSType<VkCopyTensorInfoARM>() { return VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkMemoryDedicatedAllocateInfoTensorARM>() { return VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalTensorInfoARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkExternalTensorPropertiesARM>() { return VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM; }
+template <> inline VkStructureType GetSType<VkExternalMemoryTensorCreateInfoARM>() { return VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorBufferTensorPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; }
+template <> inline VkStructureType GetSType<VkDescriptorGetTensorInfoARM>() { return VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkTensorCaptureDescriptorDataInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkTensorViewCaptureDescriptorDataInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkFrameBoundaryTensorsARM>() { return VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineShaderStageModuleIdentifierCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; }
@@ -868,12 +984,14 @@ template <> inline VkStructureType GetSType<VkOpticalFlowSessionCreateInfoNV>()
 template <> inline VkStructureType GetSType<VkOpticalFlowSessionCreatePrivateDataInfoNV>() { return VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; }
 template <> inline VkStructureType GetSType<VkOpticalFlowExecuteInfoNV>() { return VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLegacyDitheringFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT; }
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; }
 template <> inline VkStructureType GetSType<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>() { return VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID; }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
+template <> inline VkStructureType GetSType<VkPhysicalDeviceAntiLagFeaturesAMD>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; }
+template <> inline VkStructureType GetSType<VkAntiLagPresentationInfoAMD>() { return VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD; }
+template <> inline VkStructureType GetSType<VkAntiLagDataAMD>() { return VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderObjectFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderObjectPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkShaderCreateInfoEXT>() { return VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT; }
@@ -884,8 +1002,14 @@ template <> inline VkStructureType GetSType<VkAmigoProfilingSubmitInfoSEC>() { r
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeVectorPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeVectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkCooperativeVectorPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkConvertCooperativeVectorMatrixInfoNV>() { return VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkLayerSettingsCreateInfoEXT>() { return VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; }
@@ -922,6 +1046,76 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalMemoryScreen
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropertiesMSFT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM; }
+template <> inline VkStructureType GetSType<VkTileMemoryRequirementsQCOM>() { return VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM; }
+template <> inline VkStructureType GetSType<VkTileMemoryBindInfoQCOM>() { return VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkTileMemorySizeInfoQCOM>() { return VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkDisplaySurfaceStereoCreateInfoNV>() { return VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; }
+template <> inline VkStructureType GetSType<VkDisplayModeStereoPropertiesNV>() { return VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkExternalComputeQueueDeviceCreateInfoNV>() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV; }
+template <> inline VkStructureType GetSType<VkExternalComputeQueueCreateInfoNV>() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV; }
+template <> inline VkStructureType GetSType<VkExternalComputeQueueDataParamsNV>() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalComputeQueuePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderFloat8FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureClustersBottomLevelInputNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureTriangleClusterInputNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureMoveObjectsInputNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureInputInfoNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureCommandsInfoNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV; }
+template <> inline VkStructureType GetSType<VkAccelerationStructureBuildSizesInfoKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV>() { return VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPartitionedAccelerationStructureFlagsNV>() { return VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV; }
+template <> inline VkStructureType GetSType<VkWriteDescriptorSetPartitionedAccelerationStructureNV>() { return VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV; }
+template <> inline VkStructureType GetSType<VkPartitionedAccelerationStructureInstancesInputNV>() { return VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV; }
+template <> inline VkStructureType GetSType<VkBuildPartitionedAccelerationStructureInfoNV>() { return VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; }
+template <> inline VkStructureType GetSType<VkGeneratedCommandsMemoryRequirementsInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectExecutionSetPipelineInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectExecutionSetShaderLayoutInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectExecutionSetShaderInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectExecutionSetCreateInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkGeneratedCommandsInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkWriteIndirectExecutionSetPipelineEXT>() { return VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectCommandsLayoutTokenEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectCommandsLayoutCreateInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkGeneratedCommandsPipelineInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkGeneratedCommandsShaderInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkWriteIndirectExecutionSetShaderEXT>() { return VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlFeaturesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlPropertiesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; }
+template <> inline VkStructureType GetSType<VkImageAlignmentControlCreateInfoMESA>() { return VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampControlFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPipelineViewportDepthClampControlCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceHdrVividFeaturesHUAWEI>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; }
+template <> inline VkStructureType GetSType<VkHdrVividDynamicMetadataHUAWEI>() { return VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI; }
+template <> inline VkStructureType GetSType<VkCooperativeMatrixFlexibleDimensionsPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2PropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; }
+#ifdef VK_USE_PLATFORM_METAL_EXT
+template <> inline VkStructureType GetSType<VkImportMemoryMetalHandleInfoEXT>() { return VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkMemoryMetalHandlePropertiesEXT>() { return VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT; }
+template <> inline VkStructureType GetSType<VkMemoryGetMetalHandleInfoEXT>() { return VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT; }
+#endif  // VK_USE_PLATFORM_METAL_EXT
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceFormatPackFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+template <> inline VkStructureType GetSType<VkSetPresentConfigNV>() { return VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePresentMeteringFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+template <> inline VkStructureType GetSType<VkRenderingEndInfoEXT>() { return VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
@@ -936,7 +1130,6 @@ template <> inline VkStructureType GetSType<VkAccelerationStructureVersionInfoKH
 template <> inline VkStructureType GetSType<VkCopyAccelerationStructureToMemoryInfoKHR>() { return VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkCopyMemoryToAccelerationStructureInfoKHR>() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkCopyAccelerationStructureInfoKHR>() { return VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkAccelerationStructureBuildSizesInfoKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkRayTracingShaderGroupCreateInfoKHR>() { return VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkRayTracingPipelineInterfaceCreateInfoKHR>() { return VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkRayTracingPipelineCreateInfoKHR>() { return VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR; }
@@ -1012,13 +1205,12 @@ class InitStructHelper {
         return InitStruct<T>(p_next);
     }
 };
-
+#if VK_USE_64_BIT_PTR_DEFINES == 1
 template<typename T> VkObjectType GetObjectType() {
     static_assert(sizeof(T) == 0, "GetObjectType() is being used with an unsupported Type! Is the code-gen up to date?");
     return VK_OBJECT_TYPE_UNKNOWN;
 }
 
-#if VK_USE_64_BIT_PTR_DEFINES == 1
 template<> inline VkObjectType GetObjectType<VkBuffer>() { return VK_OBJECT_TYPE_BUFFER; }
 template<> inline VkObjectType GetObjectType<VkImage>() { return VK_OBJECT_TYPE_IMAGE; }
 template<> inline VkObjectType GetObjectType<VkInstance>() { return VK_OBJECT_TYPE_INSTANCE; }
@@ -1054,6 +1246,7 @@ template<> inline VkObjectType GetObjectType<VkDisplayModeKHR>() { return VK_OBJ
 template<> inline VkObjectType GetObjectType<VkVideoSessionKHR>() { return VK_OBJECT_TYPE_VIDEO_SESSION_KHR; }
 template<> inline VkObjectType GetObjectType<VkVideoSessionParametersKHR>() { return VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; }
 template<> inline VkObjectType GetObjectType<VkDeferredOperationKHR>() { return VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR; }
+template<> inline VkObjectType GetObjectType<VkPipelineBinaryKHR>() { return VK_OBJECT_TYPE_PIPELINE_BINARY_KHR; }
 template<> inline VkObjectType GetObjectType<VkDebugReportCallbackEXT>() { return VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT; }
 template<> inline VkObjectType GetObjectType<VkCuModuleNVX>() { return VK_OBJECT_TYPE_CU_MODULE_NVX; }
 template<> inline VkObjectType GetObjectType<VkCuFunctionNVX>() { return VK_OBJECT_TYPE_CU_FUNCTION_NVX; }
@@ -1062,17 +1255,29 @@ template<> inline VkObjectType GetObjectType<VkValidationCacheEXT>() { return VK
 template<> inline VkObjectType GetObjectType<VkAccelerationStructureNV>() { return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV; }
 template<> inline VkObjectType GetObjectType<VkPerformanceConfigurationINTEL>() { return VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL; }
 template<> inline VkObjectType GetObjectType<VkIndirectCommandsLayoutNV>() { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV; }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
 template<> inline VkObjectType GetObjectType<VkCudaModuleNV>() { return VK_OBJECT_TYPE_CUDA_MODULE_NV; }
 template<> inline VkObjectType GetObjectType<VkCudaFunctionNV>() { return VK_OBJECT_TYPE_CUDA_FUNCTION_NV; }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 template<> inline VkObjectType GetObjectType<VkAccelerationStructureKHR>() { return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR; }
 #ifdef VK_USE_PLATFORM_FUCHSIA
 template<> inline VkObjectType GetObjectType<VkBufferCollectionFUCHSIA>() { return VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA; }
 #endif  // VK_USE_PLATFORM_FUCHSIA
 template<> inline VkObjectType GetObjectType<VkMicromapEXT>() { return VK_OBJECT_TYPE_MICROMAP_EXT; }
+template<> inline VkObjectType GetObjectType<VkTensorARM>() { return VK_OBJECT_TYPE_TENSOR_ARM; }
+template<> inline VkObjectType GetObjectType<VkTensorViewARM>() { return VK_OBJECT_TYPE_TENSOR_VIEW_ARM; }
 template<> inline VkObjectType GetObjectType<VkOpticalFlowSessionNV>() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; }
 template<> inline VkObjectType GetObjectType<VkShaderEXT>() { return VK_OBJECT_TYPE_SHADER_EXT; }
+template<> inline VkObjectType GetObjectType<VkExternalComputeQueueNV>() { return VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; }
+template<> inline VkObjectType GetObjectType<VkIndirectExecutionSetEXT>() { return VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT; }
+template<> inline VkObjectType GetObjectType<VkIndirectCommandsLayoutEXT>() { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT; }
 
-#endif // VK_USE_64_BIT_PTR_DEFINES == 1
+# else // 32 bit
+template<typename T> VkObjectType GetObjectType() {
+    static_assert(sizeof(T) == 0, "GetObjectType() does not support 32 bit builds! This is a limitation of the vulkan.h headers");
+    return VK_OBJECT_TYPE_UNKNOWN;
+}
+# endif // VK_USE_64_BIT_PTR_DEFINES == 1
 } // namespace vku
 
 // NOLINTEND// clang-format on

scripts/common_ci.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2024 The Khronos Group Inc.
+# Copyright (c) 2015-2024 Valve Corporation
+# Copyright (c) 2015-2024 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import sys
+import subprocess
+import platform
+
+# Use Ninja for all platforms for performance/simplicity
+os.environ['CMAKE_GENERATOR'] = "Ninja"
+
+# helper to define paths relative to the repo root
+def RepoRelative(path):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', path))
+
+# Points to the directory containing the top level CMakeLists.txt
+PROJECT_SRC_DIR = os.path.abspath(os.path.join(os.path.split(os.path.abspath(__file__))[0], '..'))
+if not os.path.isfile(f'{PROJECT_SRC_DIR}/CMakeLists.txt'):
+    print(f'PROJECT_SRC_DIR invalid! {PROJECT_SRC_DIR}')
+    sys.exit(1)
+
+# Returns true if we are running in GitHub actions
+# https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables
+def IsGHA():
+    if 'GITHUB_ACTION' in os.environ:
+        return True
+    return False
+
+# Runs a command in a directory and returns its return code.
+# Directory is project root by default, or a relative path from project root
+def RunShellCmd(command, start_dir = PROJECT_SRC_DIR, env=None, verbose=False):
+    # Flush stdout here. Helps when debugging on CI.
+    sys.stdout.flush()
+
+    if start_dir != PROJECT_SRC_DIR:
+        start_dir = RepoRelative(start_dir)
+    cmd_list = command.split(" ")
+
+    # Helps a lot when debugging CI issues
+    if IsGHA():
+        verbose = True
+
+    if verbose:
+        print(f'CICMD({cmd_list}, env={env})')
+    subprocess.check_call(cmd_list, cwd=start_dir, env=env)
+
+#
+# Check if the system is Windows
+def IsWindows(): return 'windows' == platform.system().lower()

scripts/generate_source.py

@@ -8,10 +8,16 @@
 import argparse
 import os
 import sys
+import shutil
+import common_ci
 from xml.etree import ElementTree
 
 def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
 
+    has_clang_format = shutil.which('clang-format') is not None
+    if not has_clang_format:
+        print("WARNING: Unable to find clang-format!")
+
     # These live in the Vulkan-Docs repo, but are pulled in via the
     # Vulkan-Headers/registry folder
     # At runtime we inject python path to find these helper scripts
@@ -19,17 +25,24 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
     scripts_directory_path = os.path.dirname(os.path.abspath(__file__))
     registry_headers_path = os.path.join(scripts_directory_path, scripts)
     sys.path.insert(0, registry_headers_path)
-    from reg import Registry
+    try:
+        from reg import Registry
+    except:
+        print("ModuleNotFoundError: No module named 'reg'") # normal python error message
+        print(f'{registry_headers_path} is not pointing to the Vulkan-Headers registry directory.')
+        print("Inside Vulkan-Headers there is a registry/reg.py file that is used.")
+        sys.exit(1) # Return without call stack so easy to spot error
 
-    from generators.base_generator import BaseGeneratorOptions
+    from base_generator import BaseGeneratorOptions
     from generators.dispatch_table_generator import DispatchTableOutputGenerator
     from generators.enum_string_helper_generator import EnumStringHelperOutputGenerator
     from generators.format_utils_generator import FormatUtilsOutputGenerator
     from generators.struct_helper_generator import StructHelperOutputGenerator
+    from generators.safe_struct_generator import SafeStructOutputGenerator
 
     # These set fields that are needed by both OutputGenerator and BaseGenerator,
     # but are uniform and don't need to be set at a per-generated file level
-    from generators.base_generator import (SetTargetApiName, SetMergedApiNames)
+    from base_generator import (SetTargetApiName, SetMergedApiNames)
     SetTargetApiName(api)
 
     # Build up a list of all generators and custom options
@@ -37,31 +50,63 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
         'vk_dispatch_table.h' : {
            'generator' : DispatchTableOutputGenerator,
            'genCombined': True,
-           'directory' : f'include/{api}/utility',
+           'directory' : f'include/vulkan/utility',
         },
         'vk_enum_string_helper.h' : {
             'generator' : EnumStringHelperOutputGenerator,
             'genCombined': True,
-            'directory' : f'include/{api}',
+            'directory' : f'include/vulkan',
         },
         'vk_format_utils.h' : {
             'generator' : FormatUtilsOutputGenerator,
             'genCombined': True,
-            'directory' : f'include/{api}/utility',
+            'directory' : f'include/vulkan/utility',
         },
         'vk_struct_helper.hpp' : {
             'generator' : StructHelperOutputGenerator,
             'genCombined': True,
-            'directory' : f'include/{api}/utility',
+            'directory' : f'include/vulkan/utility',
+        },
+        'vk_safe_struct.hpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'include/vulkan/utility',
+        },
+        'vk_safe_struct_utils.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'src/vulkan',
+        },
+        'vk_safe_struct_core.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'regenerate' : True,
+            'directory' : f'src/vulkan',
+        },
+        'vk_safe_struct_khr.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'src/vulkan',
+        },
+        'vk_safe_struct_ext.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'src/vulkan',
+        },
+        'vk_safe_struct_vendor.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'src/vulkan',
         },
     }
 
-    if (targetFilter and targetFilter not in generators.keys()):
-        print(f'ERROR: No generator options for unknown target: {targetFilter}', file=sys.stderr)
-        sys.exit(1)
+    unknownTargets = [x for x in (targetFilter if targetFilter else []) if x not in generators.keys()]
+    if unknownTargets:
+        print(f'ERROR: No generator options for unknown target(s): {", ".join(unknownTargets)}', file=sys.stderr)
+        return 1
 
     # Filter if --target is passed in
-    targets = [x for x in generators.keys() if not targetFilter or x == targetFilter]
+    targets = [x for x in generators.keys() if not targetFilter or x in targetFilter]
 
     for index, target in enumerate(targets, start=1):
         print(f'[{index}|{len(targets)}] Generating {target}')
@@ -102,6 +147,9 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
         # Finally, use the output generator to create the requested target
         reg.apiGen()
 
+        # Run clang-format on the file
+        if has_clang_format:
+            common_ci.RunShellCmd(f'clang-format -i {os.path.join(outDirectory, target)}')
 
 def main(argv):
     parser = argparse.ArgumentParser(description='Generate source code for this repository')
@@ -111,10 +159,16 @@ def main(argv):
                         help='Specify API name to generate')
     parser.add_argument('registry', metavar='REGISTRY_PATH', help='path to the Vulkan-Headers registry directory')
     group = parser.add_mutually_exclusive_group()
-    group.add_argument('--target', help='only generate file name passed in')
+    group.add_argument('--target', nargs='+', help='only generate file name passed in')
     args = parser.parse_args(argv)
 
     registry = os.path.abspath(os.path.join(args.registry,  'vk.xml'))
+    if not os.path.isfile(registry):
+        registry = os.path.abspath(os.path.join(args.registry, 'Vulkan-Headers/registry/vk.xml'))
+        if not os.path.isfile(registry):
+            print(f'cannot find vk.xml in {args.registry}')
+            return -1
+
     RunGenerators(args.api, registry, args.target)
 
     return 0

scripts/generators/base_generator.py

@@ -1,728 +0,0 @@
-#!/usr/bin/python3 -i
-#
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
-# Copyright 2023 RasterGrid Kft.
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from generators.vulkan_object import (VulkanObject,
-    Extension, Version, Handle, Param, Queues, CommandScope, Command,
-    EnumField, Enum, Flag, Bitmask, Member, Struct,
-    FormatComponent, FormatPlane, Format,
-    SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline,
-    SpirvEnables, Spirv)
-
-# These live in the Vulkan-Docs repo, but are pulled in via the
-# Vulkan-Headers/registry folder
-from generator import OutputGenerator, GeneratorOptions, write
-from vkconventions import VulkanConventions
-
-# An API style convention object
-vulkanConventions = VulkanConventions()
-
-# Helpers to keep things cleaner
-def splitIfGet(elem, name):
-    return elem.get(name).split(',') if elem.get(name) is not None else None
-
-def textIfFind(elem, name):
-    return elem.find(name).text if elem.find(name) is not None else None
-
-def intIfGet(elem, name):
-    return None if elem.get(name) is None else int(elem.get(name), 0)
-
-def boolGet(elem, name) -> bool:
-    return elem.get(name) is not None and elem.get(name) == "true"
-
-def getQueues(elem) -> Queues:
-    queues = 0
-    queues_list = splitIfGet(elem, 'queues')
-    if queues_list is not None:
-        queues |= Queues.TRANSFER if 'transfer' in queues_list else 0
-        queues |= Queues.GRAPHICS if 'graphics' in queues_list else 0
-        queues |= Queues.COMPUTE if 'compute' in queues_list else 0
-        queues |= Queues.PROTECTED if 'protected' in queues_list else 0
-        queues |= Queues.SPARSE_BINDING if 'sparse_binding' in queues_list else 0
-        queues |= Queues.OPTICAL_FLOW if 'opticalflow' in queues_list else 0
-        queues |= Queues.DECODE if 'decode' in queues_list else 0
-        queues |= Queues.ENCODE if 'encode' in queues_list else 0
-    return queues
-
-# Shared object used by Sync elements that don't have ones
-maxSyncSupport = SyncSupport(None, None, True)
-maxSyncEquivalent = SyncEquivalent(None, None, True)
-
-# Helpers to set GeneratorOptions options globally
-def SetOutputFileName(fileName: str) -> None:
-    global globalFileName
-    globalFileName = fileName
-
-def SetOutputDirectory(directory: str) -> None:
-    global globalDirectory
-    globalDirectory = directory
-
-def SetTargetApiName(apiname: str) -> None:
-    global globalApiName
-    globalApiName = apiname
-
-def SetMergedApiNames(names: str) -> None:
-    global mergedApiNames
-    mergedApiNames = names
-
-# This class is a container for any source code, data, or other behavior that is necessary to
-# customize the generator script for a specific target API variant (e.g. Vulkan SC). As such,
-# all of these API-specific interfaces and their use in the generator script are part of the
-# contract between this repository and its downstream users. Changing or removing any of these
-# interfaces or their use in the generator script will have downstream effects and thus
-# should be avoided unless absolutely necessary.
-class APISpecific:
-    # Version object factory method
-    @staticmethod
-    def createApiVersion(targetApiName: str, name: str, number: str) -> Version:
-        match targetApiName:
-
-            # Vulkan specific API version creation
-            case 'vulkan':
-                nameApi = name.replace('VK_', 'VK_API_')
-                nameString = f'"{name}"'
-                return Version(name, nameString, nameApi, number)
-
-
-# This Generator Option is used across all generators.
-# After years of use, it has shown that most the options are unified across each generator (file)
-# as it is easier to modifiy things per-file that need the difference
-class BaseGeneratorOptions(GeneratorOptions):
-    def __init__(self,
-                 customFileName = None,
-                 customDirectory = None,
-                 customApiName = None):
-        GeneratorOptions.__init__(self,
-                conventions = vulkanConventions,
-                filename = customFileName if customFileName else globalFileName,
-                directory = customDirectory if customDirectory else globalDirectory,
-                apiname = customApiName if customApiName else globalApiName,
-                mergeApiNames = mergedApiNames,
-                defaultExtensions = customApiName if customApiName else globalApiName,
-                emitExtensions = '.*',
-                emitSpirv = '.*',
-                emitFormats = '.*')
-        # These are used by the generator.py script
-        self.apicall         = 'VKAPI_ATTR '
-        self.apientry        = 'VKAPI_CALL '
-        self.apientryp       = 'VKAPI_PTR *'
-        self.alignFuncParam   = 48
-
-#
-# This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers
-# It will grab all the data and form it into a single object the rest of the generators will use
-class BaseGenerator(OutputGenerator):
-    def __init__(self):
-        OutputGenerator.__init__(self, None, None, None)
-        self.vk = VulkanObject()
-        self.targetApiName = globalApiName
-
-        # reg.py has a `self.featureName` but this is nicer because
-        # it will be either the Version or Extension object
-        self.currentExtension = None
-        self.currentVersion = None
-
-        # Will map alias to promoted name
-        #   ex. ['VK_FILTER_CUBIC_IMG' : 'VK_FILTER_CUBIC_EXT']
-        # When generating any code, there is no reason so use the old name
-        self.enumAliasMap = dict()
-        self.enumFieldAliasMap = dict()
-        self.bitmaskAliasMap = dict()
-        self.flagAliasMap = dict()
-
-    def write(self, data):
-        # Prevents having to check before writting
-        if data is not None and data != "":
-            write(data, file=self.outFile)
-
-
-    def beginFile(self, genOpts):
-        OutputGenerator.beginFile(self, genOpts)
-        self.filename = genOpts.filename
-
-        # No gen*() command to get these, so do it manually
-        for platform in self.registry.tree.findall('platforms/platform'):
-            self.vk.platforms[platform.get('name')] = platform.get('protect')
-
-        for tags in self.registry.tree.findall('tags'):
-            for tag in tags.findall('tag'):
-                self.vk.vendorTags.append(tag.get('name'))
-
-        # No way known to get this from the XML
-        self.vk.queueBits[Queues.TRANSFER]       = 'VK_QUEUE_TRANSFER_BIT'
-        self.vk.queueBits[Queues.GRAPHICS]       = 'VK_QUEUE_GRAPHICS_BIT'
-        self.vk.queueBits[Queues.COMPUTE]        = 'VK_QUEUE_COMPUTE_BIT'
-        self.vk.queueBits[Queues.PROTECTED]      = 'VK_QUEUE_PROTECTED_BIT'
-        self.vk.queueBits[Queues.SPARSE_BINDING] = 'VK_QUEUE_SPARSE_BINDING_BIT'
-        self.vk.queueBits[Queues.OPTICAL_FLOW]   = 'VK_QUEUE_OPTICAL_FLOW_BIT_NV'
-        self.vk.queueBits[Queues.DECODE]         = 'VK_QUEUE_VIDEO_DECODE_BIT_KHR'
-        self.vk.queueBits[Queues.ENCODE]         = 'VK_QUEUE_VIDEO_ENCODE_BIT_KHR'
-
-    # This function should be overloaded
-    def generate(self):
-        print("WARNING: This should not be called from the child class")
-        return
-
-    # This function is dense, it does all the magic to set the right extensions dependencies!
-    #
-    # The issue is if 2 extension expose a command, genCmd() will only
-    # show one of the extension, at endFile() we can finally go through
-    # and update which things depend on which extensions
-    #
-    # self.featureDictionary is built for use in the reg.py framework
-    # Details found in Vulkan-Docs/scripts/scriptgenerator.py
-    def applyExtensionDependency(self):
-        for extension in self.vk.extensions.values():
-            # dict.key() can be None, so need to double loop
-            dict = self.featureDictionary[extension.name]['command']
-
-            # "required" == None
-            #         or
-            #  an additional feature dependency, which is a boolean expression of
-            #  one or more extension and/or core version names
-            for required in dict:
-                for commandName in dict[required]:
-                    # Skip commands removed in the target API
-                    # This check is needed because parts of the base generator code bypass the
-                    # dependency resolution logic in the registry tooling and thus the generator
-                    # may attempt to generate code for commands which are not supported in the
-                    # target API variant, thus this check needs to happen even if any specific
-                    # target API variant may not specifically need it
-                    if not commandName in self.vk.commands:
-                        continue
-
-                    command = self.vk.commands[commandName]
-                    # Make sure list is unique
-                    command.extensions.extend([extension] if extension not in command.extensions else [])
-                    extension.commands.extend([command] if command not in extension.commands else [])
-
-            # While genGroup() will call twice with aliased value, it doesn't provide all the information we need
-            dict = self.featureDictionary[extension.name]['enumconstant']
-            for required in dict:
-                # group can be a Enum or Bitmask
-                for group in dict[required]:
-                    if group in self.vk.enums:
-                        if group not in extension.enumFields:
-                            extension.enumFields[group] = [] # Dict needs init
-                        enum = self.vk.enums[group]
-                        # Need to convert all alias so they match what is in EnumField
-                        enumList = list(map(lambda x: x if x not in self.enumFieldAliasMap else self.enumFieldAliasMap[x], dict[required][group]))
-
-                        for enumField in [x for x in enum.fields if x.name in enumList]:
-                            # Make sure list is unique
-                            enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
-                            enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
-                            extension.enumFields[group].extend([enumField] if enumField not in extension.enumFields[group] else [])
-
-                    if group in self.vk.bitmasks:
-                        if group not in extension.flags:
-                            extension.flags[group] = [] # Dict needs init
-                        bitmask = self.vk.bitmasks[group]
-                        # Need to convert all alias so they match what is in Flags
-                        flagList = list(map(lambda x: x if x not in self.flagAliasMap else self.flagAliasMap[x], dict[required][group]))
-
-                        for flags in [x for x in bitmask.flags if x.name in flagList]:
-                            # Make sure list is unique
-                            bitmask.extensions.extend([extension] if extension not in bitmask.extensions else [])
-                            flags.extensions.extend([extension] if extension not in flags.extensions else [])
-                            extension.flags[group].extend([flags] if flags not in extension.flags[group] else [])
-
-
-        # Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions
-        #
-        # Sometimes two extensions enable an Enum, but the newer extension version has extra flags allowed
-        # This information seems to be implicit, so need to update it here
-        # Go through each Flag and append the Enum extension to it
-        #
-        # ex. VkAccelerationStructureTypeKHR where GENERIC_KHR is not allowed with just VK_NV_ray_tracing
-        # This only works because the values are aliased as well, making the KHR a superset enum
-        for extension in self.vk.extensions.values():
-            dict = self.featureDictionary[extension.name]['enum']
-            for required in dict:
-                for group in dict[required]:
-                    for enumName in dict[required][group]:
-                        isAlias = enumName in self.enumAliasMap
-                        enumName = self.enumAliasMap[enumName] if isAlias else enumName
-                        if enumName in self.vk.enums:
-                            enum = self.vk.enums[enumName]
-                            enum.extensions.extend([extension] if extension not in enum.extensions else [])
-                            extension.enums.extend([enum] if enum not in extension.enums else [])
-                            # Update fields with implicit base extension
-                            if isAlias:
-                                continue
-                            enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
-                            for enumField in [x for x in enum.fields if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]:
-                                enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
-                                if enumName not in extension.enumFields:
-                                    extension.enumFields[enumName] = [] # Dict needs init
-                                extension.enumFields[enumName].extend([enumField] if enumField not in extension.enumFields[enumName] else [])
-
-            dict = self.featureDictionary[extension.name]['bitmask']
-            for required in dict:
-                for group in dict[required]:
-                    for bitmaskName in dict[required][group]:
-                        isAlias = bitmaskName in self.enumAliasMap
-                        bitmaskName = self.bitmaskAliasMap[bitmaskName] if isAlias else bitmaskName
-                        if bitmaskName in self.vk.bitmasks:
-                            bitmask = self.vk.bitmasks[bitmaskName]
-                            bitmask.extensions.extend([extension] if extension not in bitmask.extensions else [])
-                            extension.bitmask.extend([bitmask] if bitmask not in extension.bitmasks else [])
-                            # Update flags with implicit base extension
-                            if isAlias:
-                                continue
-                            bitmask.flagExtensions.extend([extension] if extension not in enum.flagExtensions else [])
-                            for flag in [x for x in enum.flags if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]:
-                                flag.extensions.extend([extension] if extension not in flag.extensions else [])
-                                if bitmaskName not in extension.flags:
-                                    extension.flags[bitmaskName] = [] # Dict needs init
-                                extension.flags[bitmaskName].extend([flag] if flag not in extension.flags[bitmaskName] else [])
-
-    def endFile(self):
-        # This is the point were reg.py has ran, everything is collected
-        # We do some post processing now
-        self.applyExtensionDependency()
-
-        # Use structs and commands to find which things are returnedOnly
-        for struct in [x for x in self.vk.structs.values() if not x.returnedOnly]:
-            for enum in [self.vk.enums[x.type] for x in struct.members if x.type in self.vk.enums]:
-                enum.returnedOnly = False
-        for command in self.vk.commands.values():
-            for enum in [self.vk.enums[x.type] for x in command.params if x.type in self.vk.enums]:
-                enum.returnedOnly = False
-
-        # Turn handle parents into pointers to classess
-        for handle in [x for x in self.vk.handles.values() if x.parent is not None]:
-            handle.parent = self.vk.handles[handle.parent]
-        # search up parent chain to see if instance or device
-        for handle in [x for x in self.vk.handles.values()]:
-            next_parent = handle.parent
-            while (not handle.instance and not handle.device):
-                handle.instance = next_parent.name == 'VkInstance'
-                handle.device = next_parent.name == 'VkDevice'
-                next_parent = next_parent.parent
-
-        maxSyncSupport.queues = Queues.ALL
-        maxSyncSupport.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
-        maxSyncEquivalent.accesses = self.vk.bitmasks['VkAccessFlagBits2'].flags
-        maxSyncEquivalent.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
-
-        # All inherited generators should run from here
-        self.generate()
-
-        # This should not have to do anything but call into OutputGenerator
-        OutputGenerator.endFile(self)
-
-    #
-    # Processing point at beginning of each extension definition
-    def beginFeature(self, interface, emit):
-        OutputGenerator.beginFeature(self, interface, emit)
-        platform = interface.get('platform')
-        self.featureExtraProtec = self.vk.platforms[platform] if platform in self.vk.platforms else None
-        protect = self.vk.platforms[platform] if platform in self.vk.platforms else None
-
-        name = interface.get('name')
-
-        if interface.tag == 'extension':
-            instance = interface.get('type') == 'instance'
-            device = not instance
-            depends = interface.get('depends')
-            vendorTag = interface.get('author')
-            platform = interface.get('platform')
-            provisional = boolGet(interface, 'provisional')
-            promotedto = interface.get('promotedto')
-            deprecatedby = interface.get('deprecatedby')
-            obsoletedby = interface.get('obsoletedby')
-            specialuse = splitIfGet(interface, 'specialuse')
-            # Not sure if better way to get this info
-            nameString = self.featureDictionary[name]['enumconstant'][None][None][1]
-
-            self.currentExtension = Extension(name, nameString, instance, device, depends, vendorTag,
-                                            platform, protect, provisional, promotedto, deprecatedby,
-                                            obsoletedby, specialuse)
-            self.vk.extensions[name] = self.currentExtension
-        else: # version
-            number = interface.get('number')
-            if number != '1.0':
-                self.currentVersion = APISpecific.createApiVersion(self.targetApiName, name, number)
-                self.vk.versions[name] = self.currentVersion
-
-    def endFeature(self):
-        OutputGenerator.endFeature(self)
-        self.currentExtension = None
-        self.currentVersion = None
-
-    #
-    # All <command> from XML
-    def genCmd(self, cmdinfo, name, alias):
-        OutputGenerator.genCmd(self, cmdinfo, name, alias)
-
-        params = []
-        for param in cmdinfo.elem.findall('param'):
-            paramName = param.find('name').text
-            paramType = textIfFind(param, 'type')
-            paramAlias = param.get('alias')
-
-            cdecl = self.makeCParamDecl(param, 0)
-            pointer = '*' in cdecl or paramType.startswith('PFN_')
-            paramConst = 'const' in cdecl
-            fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
-
-            paramNoautovalidity = boolGet(param, 'noautovalidity')
-
-            nullTerminated = False
-            length = param.get('altlen') if param.get('altlen') is not None else param.get('len')
-            if length:
-                # we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
-                # This finds both
-                nullTerminated = 'null-terminated' in length
-                length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
-                length = None if length == 'null-terminated' else length
-
-            if fixedSizeArray and not length:
-                length = ','.join(fixedSizeArray)
-
-            # See Member::optional code for details of this
-            optionalValues = splitIfGet(param, 'optional')
-            optional = optionalValues is not None and optionalValues[0].lower() == "true"
-            optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
-
-            # externsync will be 'true' or expression
-            # if expression, it should be same as 'true'
-            externSync = boolGet(param, 'externsync')
-            externSyncPointer = None if externSync else splitIfGet(param, 'externsync')
-            if not externSync and externSyncPointer is not None:
-                externSync = True
-
-            params.append(Param(paramName, paramAlias, paramType, paramNoautovalidity,
-                                paramConst, length, nullTerminated, pointer, fixedSizeArray,
-                                optional, optionalPointer,
-                                externSync, externSyncPointer, cdecl))
-
-        attrib = cmdinfo.elem.attrib
-        alias = attrib.get('alias')
-        tasks = splitIfGet(attrib, 'tasks')
-
-        queues = getQueues(attrib)
-        successcodes = splitIfGet(attrib, 'successcodes')
-        errorcodes = splitIfGet(attrib, 'errorcodes')
-        cmdbufferlevel = attrib.get('cmdbufferlevel')
-        primary = cmdbufferlevel is not None and 'primary' in cmdbufferlevel
-        secondary = cmdbufferlevel is not None and 'secondary' in cmdbufferlevel
-
-        renderpass = attrib.get('renderpass')
-        renderpass = CommandScope.NONE if renderpass is None else getattr(CommandScope, renderpass.upper())
-        videocoding = attrib.get('videocoding')
-        videocoding = CommandScope.NONE if videocoding is None else getattr(CommandScope, videocoding.upper())
-
-        protoElem = cmdinfo.elem.find('proto')
-        returnType = textIfFind(protoElem, 'type')
-
-        decls = self.makeCDecls(cmdinfo.elem)
-        cPrototype = decls[0]
-        cFunctionPointer = decls[1]
-
-        protect = self.currentExtension.protect if self.currentExtension is not None else None
-
-        # These coammds have no way from the XML to detect they would be an instance command
-        specialInstanceCommand = ['vkCreateInstance', 'vkEnumerateInstanceExtensionProperties','vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceVersion']
-        instance = len(params) > 0 and (params[0].type == 'VkInstance' or params[0].type == 'VkPhysicalDevice' or name in specialInstanceCommand)
-        device = not instance
-
-        implicitElem = cmdinfo.elem.find('implicitexternsyncparams')
-        implicitExternSyncParams = [x.text for x in implicitElem.findall('param')] if implicitElem else []
-
-        self.vk.commands[name] = Command(name, alias, protect, [], self.currentVersion,
-                                         returnType, params, instance, device,
-                                         tasks, queues, successcodes, errorcodes,
-                                         primary, secondary, renderpass, videocoding,
-                                         implicitExternSyncParams, cPrototype, cFunctionPointer)
-
-    #
-    # List the enum for the commands
-    # TODO - Seems empty groups like `VkDeviceDeviceMemoryReportCreateInfoEXT` don't show up in here
-    def genGroup(self, groupinfo, groupName, alias):
-        # There can be case where the Enum/Bitmask is in a protect, but the individual
-        # fields also have their own protect
-        groupProtect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
-        enumElem = groupinfo.elem
-        bitwidth = 32 if enumElem.get('bitwidth') is None else enumElem.get('bitwidth')
-        fields = []
-        if enumElem.get('type') == "enum":
-            if alias is not None:
-                self.enumAliasMap[groupName] = alias
-                return
-
-            for elem in enumElem.findall('enum'):
-                fieldName = elem.get('name')
-
-                if elem.get('alias') is not None:
-                    self.enumFieldAliasMap[fieldName] = elem.get('alias')
-                    continue
-
-                negative = elem.get('dir') is not None
-                protect = elem.get('protect')
-
-                # Some values have multiple extensions (ex VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
-                # genGroup() lists them twice
-                if next((x for x in fields if x.name == fieldName), None) is None:
-                    fields.append(EnumField(fieldName, negative, protect, []))
-
-            self.vk.enums[groupName] = Enum(groupName, groupProtect, bitwidth, True, fields, [], [])
-
-        else: # "bitmask"
-            if alias is not None:
-                self.bitmaskAliasMap[groupName] = alias
-                return
-
-            for elem in enumElem.findall('enum'):
-                flagName = elem.get('name')
-
-                if elem.get('alias') is not None:
-                    self.flagAliasMap[flagName] = elem.get('alias')
-                    continue
-
-                flagMultiBit = False
-                flagZero = False
-                flagValue = intIfGet(elem, 'bitpos')
-                if flagValue is None:
-                    flagValue = intIfGet(elem, 'value')
-                    flagMultiBit = flagValue != 0
-                    flagZero = flagValue == 0
-                protect = elem.get('protect')
-
-                # Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
-                # genGroup() lists them twice
-                if next((x for x in fields if x.name == flagName), None) is None:
-                    fields.append(Flag(flagName, protect, flagValue, flagMultiBit, flagZero, []))
-
-            flagName = groupName.replace('FlagBits', 'Flags')
-            self.vk.bitmasks[groupName] = Bitmask(groupName, flagName, groupProtect, bitwidth, fields, [], [])
-
-    def genType(self, typeInfo, typeName, alias):
-        OutputGenerator.genType(self, typeInfo, typeName, alias)
-        typeElem = typeInfo.elem
-        protect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
-        category = typeElem.get('category')
-        if (category == 'struct' or category == 'union'):
-            extension = [self.currentExtension] if self.currentExtension is not None else []
-            if alias is not None:
-                struct = self.vk.structs[alias]
-                # Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension
-                struct.extensions += extension if extension and extension[0] not in struct.extensions else []
-                struct.version = self.currentVersion if struct.version is None else struct.version
-                return
-
-            union = category == 'union'
-
-            returnedOnly = boolGet(typeElem, 'returnedonly')
-            allowDuplicate = boolGet(typeElem, 'allowduplicate')
-
-            extends = splitIfGet(typeElem, 'structextends')
-            extendedBy = self.registry.validextensionstructs[typeName] if len(self.registry.validextensionstructs[typeName]) > 0 else None
-
-            membersElem = typeInfo.elem.findall('.//member')
-            members = []
-            sType = None
-
-            for member in membersElem:
-                for comment in member.findall('comment'):
-                    member.remove(comment)
-
-                name = textIfFind(member, 'name')
-                type = textIfFind(member, 'type')
-                sType = member.get('values') if member.get('values') is not None else sType
-                externSync = boolGet(member, 'externsync')
-                noautovalidity = boolGet(member, 'noautovalidity')
-                limittype = member.get('limittype')
-
-                nullTerminated = False
-                length = member.get('altlen') if member.get('altlen') is not None else member.get('len')
-                if length:
-                    # we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
-                    # This finds both
-                    nullTerminated = 'null-terminated' in length
-                    length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
-                    length = None if length == 'null-terminated' else length
-
-                cdecl = self.makeCParamDecl(member, 0)
-                pointer = '*' in cdecl or type.startswith('PFN_')
-                const = 'const' in cdecl
-                # Some structs like VkTransformMatrixKHR have a 2D array
-                fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
-
-                if fixedSizeArray and not length:
-                    length = ','.join(fixedSizeArray)
-
-                # if a pointer, this can be a something like:
-                #     optional="true,false" for ppGeometries
-                #     optional="false,true" for pPhysicalDeviceCount
-                # the first is if the variable itself is optional
-                # the second is the value of the pointer is optiona;
-                optionalValues = splitIfGet(member, 'optional')
-                optional = optionalValues is not None and optionalValues[0].lower() == "true"
-                optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
-
-                members.append(Member(name, type, noautovalidity, limittype,
-                                      const, length, nullTerminated, pointer, fixedSizeArray,
-                                      optional, optionalPointer,
-                                      externSync, cdecl))
-
-            self.vk.structs[typeName] = Struct(typeName, extension, self.currentVersion, protect, members,
-                                               union, returnedOnly, sType, allowDuplicate, extends, extendedBy)
-
-        elif category == 'handle':
-            if alias is not None:
-                return
-            type = typeElem.get('objtypeenum')
-
-            # will resolve these later, the VulkanObjectType doesn't list things in dependent order
-            parent = typeElem.get('parent')
-            instance = typeName == 'VkInstance'
-            device = typeName == 'VkDevice'
-
-            dispatchable = typeElem.find('type').text == 'VK_DEFINE_HANDLE'
-
-            self.vk.handles[typeName] = Handle(typeName, type, protect, parent, instance, device, dispatchable)
-
-        elif category == 'define':
-            if typeName == 'VK_HEADER_VERSION':
-                self.vk.headerVersion = typeElem.find('name').tail.strip()
-
-        else:
-            # not all categories are used
-            #   'group'/'enum'/'bitmask' are routed to genGroup instead
-            #   'basetype'/'include' are only for headers
-            #   'funcpointer` ingore until needed
-            return
-
-    def genSpirv(self, spirvinfo, spirvName, alias):
-        OutputGenerator.genSpirv(self, spirvinfo, spirvName, alias)
-        spirvElem = spirvinfo.elem
-        name = spirvElem.get('name')
-        extension = True if spirvElem.tag == 'spirvextension' else False
-        capability = not extension
-
-        enables = []
-        for elem in spirvElem:
-            version = elem.attrib.get('version')
-            extensionEnable = elem.attrib.get('extension')
-            struct = elem.attrib.get('struct')
-            feature = elem.attrib.get('feature')
-            requires = elem.attrib.get('requires')
-            propertyEnable = elem.attrib.get('property')
-            member = elem.attrib.get('member')
-            value = elem.attrib.get('value')
-            enables.append(SpirvEnables(version, extensionEnable, struct, feature,
-                                        requires, propertyEnable, member, value))
-
-        self.vk.spirv.append(Spirv(name, extension, capability, enables))
-
-    def genFormat(self, format, formatinfo, alias):
-        OutputGenerator.genFormat(self, format, formatinfo, alias)
-        formatElem = format.elem
-        name = formatElem.get('name')
-
-        components = []
-        for component in formatElem.iterfind('component'):
-            type = component.get('name')
-            bits = component.get('bits')
-            numericFormat = component.get('numericFormat')
-            planeIndex = intIfGet(component, 'planeIndex')
-            components.append(FormatComponent(type, bits, numericFormat, planeIndex))
-
-        planes = []
-        for plane in formatElem.iterfind('plane'):
-            index = int(plane.get('index'))
-            widthDivisor = int(plane.get('widthDivisor'))
-            heightDivisor = int(plane.get('heightDivisor'))
-            compatible = plane.get('compatible')
-            planes.append(FormatPlane(index, widthDivisor, heightDivisor, compatible))
-
-        className = formatElem.get('class')
-        blockSize = int(formatElem.get('blockSize'))
-        texelsPerBlock = int(formatElem.get('texelsPerBlock'))
-        blockExtent = splitIfGet(formatElem, 'blockExtent')
-        packed = intIfGet(formatElem, 'packed')
-        chroma = formatElem.get('chroma')
-        compressed = formatElem.get('compressed')
-        spirvImageFormat = formatElem.find('spirvimageformat')
-        if spirvImageFormat is not None:
-            spirvImageFormat = spirvImageFormat.get('name')
-
-        self.vk.formats[name] = Format(name, className, blockSize, texelsPerBlock,
-                                       blockExtent, packed, chroma, compressed,
-                                       components, planes, spirvImageFormat)
-
-    def genSyncStage(self, sync):
-        OutputGenerator.genSyncStage(self, sync)
-        syncElem = sync.elem
-
-        support = maxSyncSupport
-        supportElem = syncElem.find('syncsupport')
-        if supportElem is not None:
-            queues = getQueues(supportElem)
-            stageNames = splitIfGet(supportElem, 'stage')
-            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
-            support = SyncSupport(queues, stages, False)
-
-        equivalent = maxSyncEquivalent
-        equivalentElem = syncElem.find('syncequivalent')
-        if equivalentElem is not None:
-            stageNames = splitIfGet(equivalentElem, 'stage')
-            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
-            accessNames = splitIfGet(equivalentElem, 'access')
-            accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
-            equivalent = SyncEquivalent(stages, accesses, False)
-
-        flagName = syncElem.get('name')
-        flag = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name == flagName]
-        # This check is needed because not all API variants have VK_KHR_synchronization2
-        if flag:
-            self.vk.syncStage.append(SyncStage(flag[0], support, equivalent))
-
-    def genSyncAccess(self, sync):
-        OutputGenerator.genSyncAccess(self, sync)
-        syncElem = sync.elem
-
-        support = maxSyncSupport
-        supportElem = syncElem.find('syncsupport')
-        if supportElem is not None:
-            queues = getQueues(supportElem)
-            stageNames = splitIfGet(supportElem, 'stage')
-            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
-            support = SyncSupport(queues, stages, False)
-
-        equivalent = maxSyncEquivalent
-        equivalentElem = syncElem.find('syncequivalent')
-        if equivalentElem is not None:
-            stageNames = splitIfGet(equivalentElem, 'stage')
-            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
-            accessNames = splitIfGet(equivalentElem, 'access')
-            accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
-            equivalent = SyncEquivalent(stages, accesses, False)
-
-        flagName = syncElem.get('name')
-        flag = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name == flagName]
-        # This check is needed because not all API variants have VK_KHR_synchronization2
-        if flag:
-            self.vk.syncAccess.append(SyncAccess(flag[0], support, equivalent))
-
-    def genSyncPipeline(self, sync):
-        OutputGenerator.genSyncPipeline(self, sync)
-        syncElem = sync.elem
-        name = syncElem.get('name')
-        depends = splitIfGet(syncElem, 'depends')
-        stages = []
-        for stageElem in syncElem.findall('syncpipelinestage'):
-            order = stageElem.get('order')
-            before = stageElem.get('before')
-            after = stageElem.get('after')
-            value = stageElem.text
-            stages.append(SyncPipelineStage(order, before, after, value))
-
-        self.vk.syncPipeline.append(SyncPipeline(name, depends, stages))

scripts/generators/dispatch_table_generator.py

@@ -7,7 +7,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-from generators.base_generator import BaseGenerator
+from base_generator import BaseGenerator
 from generators.generator_utils import PlatformGuardHelper
 
 class DispatchTableOutputGenerator(BaseGenerator):
@@ -44,9 +44,9 @@ typedef struct VkuInstanceDispatchTable_ {
 ''')
         guard_helper = PlatformGuardHelper()
         for command in [x for x in self.vk.commands.values() if x.instance]:
-            out.extend(guard_helper.addGuard(command.protect))
+            out.extend(guard_helper.add_guard(command.protect))
             out.append(f'    PFN_{command.name} {command.name[2:]};\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('} VkuInstanceDispatchTable;\n')
 
         out.append('''
@@ -54,9 +54,9 @@ typedef struct VkuInstanceDispatchTable_ {
 typedef struct VkuDeviceDispatchTable_ {
 ''')
         for command in [x for x in self.vk.commands.values() if x.device]:
-            out.extend(guard_helper.addGuard(command.protect))
+            out.extend(guard_helper.add_guard(command.protect))
             out.append(f'    PFN_{command.name} {command.name[2:]};\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('} VkuDeviceDispatchTable;\n')
 
         out.append('''
@@ -67,9 +67,9 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
 ''')
 
         for command in [x for x in self.vk.commands.values() if x.device and x.name != 'vkGetDeviceProcAddr']:
-            out.extend(guard_helper.addGuard(command.protect))
+            out.extend(guard_helper.add_guard(command.protect))
             out.append(f'    table->{command.name[2:]} = (PFN_{command.name})gdpa(device, "{command.name}");\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('}\n')
 
         out.append('''
@@ -89,9 +89,9 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance
                 'vkEnumerateInstanceVersion',
                 'vkGetInstanceProcAddr',
         ]]:
-            out.extend(guard_helper.addGuard(command.protect))
+            out.extend(guard_helper.add_guard(command.protect))
             out.append(f'    table->{command.name[2:]} = (PFN_{command.name})gipa(instance, "{command.name}");\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('}\n')
 
         out.append('// clang-format on')

scripts/generators/enum_string_helper_generator.py

@@ -1,13 +1,13 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2025 The Khronos Group Inc.
+# Copyright 2023-2025 Valve Corporation
+# Copyright 2023-2025 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-from generators.base_generator import BaseGenerator
+from base_generator import BaseGenerator
 from generators.generator_utils import PlatformGuardHelper
 
 class EnumStringHelperOutputGenerator(BaseGenerator):
@@ -18,9 +18,9 @@ class EnumStringHelperOutputGenerator(BaseGenerator):
         out = []
         out.append(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See {os.path.basename(__file__)} for modifications
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 ''')
@@ -39,20 +39,20 @@ class EnumStringHelperOutputGenerator(BaseGenerator):
         # If there are no fields (empty enum) ignore
         for enum in [x for x in self.vk.enums.values() if len(x.fields) > 0]:
             groupType = enum.name if enum.bitWidth == 32 else 'uint64_t'
-            out.extend(guard_helper.addGuard(enum.protect))
+            out.extend(guard_helper.add_guard(enum.protect))
             out.append(f'static inline const char* string_{enum.name}({groupType} input_value) {{\n')
             out.append('    switch (input_value) {\n')
             enum_field_guard_helper = PlatformGuardHelper()
             for field in enum.fields:
-                out.extend(enum_field_guard_helper.addGuard(field.protect))
+                out.extend(enum_field_guard_helper.add_guard(field.protect))
                 out.append(f'        case {field.name}:\n')
                 out.append(f'            return "{field.name}";\n')
-            out.extend(enum_field_guard_helper.addGuard(None))
+            out.extend(enum_field_guard_helper.add_guard(None))
             out.append('        default:\n')
             out.append(f'            return "Unhandled {enum.name}";\n')
             out.append('    }\n')
             out.append('}\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('\n')
 
         # For bitmask, first create a string for FlagBits, then a Flags version that calls into it
@@ -65,26 +65,26 @@ class EnumStringHelperOutputGenerator(BaseGenerator):
             if groupType == 'uint64_t':
                 use_switch_statement = False
 
-            out.extend(guard_helper.addGuard(bitmask.protect))
+            out.extend(guard_helper.add_guard(bitmask.protect))
             out.append(f'static inline const char* string_{bitmask.name}({groupType} input_value) {{\n')
 
             bitmask_field_guard_helper = PlatformGuardHelper()
             if use_switch_statement:
                 out.append('    switch (input_value) {\n')
                 for flag in [x for x in bitmask.flags if not x.multiBit]:
-                    out.extend(bitmask_field_guard_helper.addGuard(flag.protect))
+                    out.extend(bitmask_field_guard_helper.add_guard(flag.protect))
                     out.append(f'        case {flag.name}:\n')
                     out.append(f'            return "{flag.name}";\n')
-                out.extend(bitmask_field_guard_helper.addGuard(None))
+                out.extend(bitmask_field_guard_helper.add_guard(None))
                 out.append('        default:\n')
                 out.append(f'            return "Unhandled {bitmask.name}";\n')
                 out.append('    }\n')
             else:
                 # We need to use if statements
                 for flag in [x for x in bitmask.flags if not x.multiBit]:
-                    out.extend(bitmask_field_guard_helper.addGuard(flag.protect))
+                    out.extend(bitmask_field_guard_helper.add_guard(flag.protect))
                     out.append(f'    if (input_value == {flag.name}) return "{flag.name}";\n')
-                out.extend(bitmask_field_guard_helper.addGuard(None))
+                out.extend(bitmask_field_guard_helper.add_guard(None))
                 out.append(f'    return "Unhandled {bitmask.name}";\n')
             out.append('}\n')
 
@@ -110,6 +110,23 @@ static inline std::string string_{bitmask.flagName}({bitmask.flagName} input_val
     return ret;
 }}\n''')
             out.append('#endif // __cplusplus\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('// clang-format on')
+
+        # Special lookup for struct name of VkStructureType (since the sType name is not always that helpful)
+        out.append('''\n
+                   // Same thing as string_VkStructureType, but prints out the API name
+                   static inline const char* string_VkStructureName(VkStructureType input_value) {
+                        switch (input_value) {\n''')
+        struct_guard_helper = PlatformGuardHelper()
+        for struct in [x for x in self.vk.structs.values() if x.sType]:
+            out.extend(struct_guard_helper.add_guard(struct.protect))
+            out.append(f'        case {struct.sType}:\n')
+            out.append(f'            return "{struct.name}";\n')
+        out.append('''    default:
+                            return "Unhandled VkStructureType";
+                        }
+                    }
+                   ''')
+
         self.write("".join(out))

scripts/generators/format_utils_generator.py

@@ -1,14 +1,15 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2025 The Khronos Group Inc.
+# Copyright 2023-2025 Valve Corporation
+# Copyright 2023-2025 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-from generators.vulkan_object import (Format)
-from generators.base_generator import BaseGenerator
+from collections import namedtuple
+from vulkan_object import (Format)
+from base_generator import BaseGenerator
 
 # Make C name friendly class name
 def getClassName(className: str) -> str:
@@ -25,7 +26,13 @@ def formatHasEqualBitsize(format: Format, bitsize: str) -> bool:
 
 # True if all components are same numericFormat
 def formatHasNumericFormat(format: Format, numericFormat: str) -> bool:
-    return all(x.numericFormat == numericFormat for x in format.components)
+    if numericFormat == 'SRGB':
+        # For SRGB, the Alpha will be UNORM, but it is still considered an SRGB format
+        if format.name == 'VK_FORMAT_A8_UNORM':
+            return False
+        return all(x.type == 'A' or x.numericFormat == numericFormat for x in format.components)
+    else:
+        return all(x.numericFormat == numericFormat for x in format.components)
 
 class FormatUtilsOutputGenerator(BaseGenerator):
     def __init__(self):
@@ -71,9 +78,9 @@ class FormatUtilsOutputGenerator(BaseGenerator):
         out = []
         out.append(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See {os.path.basename(__file__)} for modifications
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 ''')
@@ -195,6 +202,8 @@ inline bool vkuFormatIsSinglePlane_422(VkFormat format);
 inline uint32_t vkuFormatPlaneCount(VkFormat format);
 
 // Returns whether a VkFormat is multiplane
+// Note - Formats like VK_FORMAT_G8B8G8R8_422_UNORM are NOT multi-planar, they require a
+//        VkSamplerYcbcrConversion and you should use vkuFormatRequiresYcbcrConversion instead
 inline bool vkuFormatIsMultiplane(VkFormat format) { return ((vkuFormatPlaneCount(format)) > 1u); }
 
 // Returns a VkFormat that is compatible with a given plane of a multiplane format
@@ -205,6 +214,10 @@ inline VkFormat vkuFindMultiplaneCompatibleFormat(VkFormat mp_fmt, VkImageAspect
 // Will return {1, 1} if given a plane aspect that doesn't exist for the VkFormat
 inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspectFlagBits plane_aspect);
 
+// From table in spec vkspec.html#formats-compatible-zs-color
+// Introduced in VK_KHR_maintenance8 to allow copying between color and depth/stencil formats
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask);
+
 // Returns the count of components in a VkFormat
 inline uint32_t vkuFormatComponentCount(VkFormat format);
 
@@ -214,24 +227,14 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format);
 // Returns the Compatibility Class of a VkFormat as defined by the spec
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format);
 
-// Return true if a VkFormat is 'normal', with one texel per format element
-inline bool vkuFormatElementIsTexel(VkFormat format);
+// Returns the number of texels inside a texel block
+// Will always be 1 when not using compressed block formats
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format);
 
-// Return size, in bytes, of one element of a VkFormat
-// Format must not be a depth, stencil, or multiplane format
-inline uint32_t vkuFormatElementSize(VkFormat format);
-
-// Return the size in bytes of one texel of a VkFormat
-// For compressed or multi-plane, this may be a fractional number
-inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);
-
-// Return the size in bytes of one texel of a VkFormat
-// Format must not be a depth, stencil, or multiplane format
-inline double vkuFormatTexelSize(VkFormat format);
-
-// Return the size in bytes of one texel of a VkFormat
-// For compressed or multi-plane, this may be a fractional number
-inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);
+// Returns the number of bytes in a single Texel Block.
+// When dealing with a depth/stencil format, need to consider using vkuFormatStencilSize or vkuFormatDepthSize.
+// When dealing with mulit-planar formats, need to consider using vkuGetPlaneIndex.
+inline uint32_t vkuFormatTexelBlockSize(VkFormat format);
 
 ''')
         for bits in ['8', '16', '32', '64']:
@@ -278,7 +281,7 @@ enum VKU_FORMAT_COMPONENT_TYPE {
 };
 
 // Compressed formats don't have a defined component size
-const uint32_t VKU_FORMAT_COMPRESSED_COMPONENT = 0xFFFFFFFF;
+#define VKU_FORMAT_COMPRESSED_COMPONENT 0xFFFFFFFF
 
 struct VKU_FORMAT_COMPONENT_INFO {
     enum VKU_FORMAT_COMPONENT_TYPE type;
@@ -288,34 +291,64 @@ struct VKU_FORMAT_COMPONENT_INFO {
 // Generic information for all formats
 struct VKU_FORMAT_INFO {
     enum VKU_FORMAT_COMPATIBILITY_CLASS compatibility;
-    uint32_t block_size;  // bytes
-    uint32_t texel_per_block;
+    uint32_t texel_block_size;  // bytes
+    uint32_t texels_per_block;
     VkExtent3D block_extent;
     uint32_t component_count;
     struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
 };
 ''')
-        out.append('inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {\n')
-        out.append('    switch (format) {\n')
-        for f in self.vk.formats.values():
+        formats_in_order = {}
+        # Manually add in the entry for VK_FORMAT_UNDEFINED because it is missing from the self.vk.formats dict
+        formats_in_order[0] = Format('VK_FORMAT_UNDEFINED', 'NONE', 0,0, ['0','0','0'], None, None, None, [], [], None)
+        for e in self.vk.enums['VkFormat'].fields:
+            if e.name != 'VK_FORMAT_UNDEFINED':
+                formats_in_order[e.value] = self.vk.formats[e.name]
+        # Number of VkFormats should equal the fields of the VkFormat enum
+        assert(len(formats_in_order) == len(self.vk.enums['VkFormat'].fields))
+        formats_in_order = dict(sorted(formats_in_order.items()))
+
+        out.append(f'const struct VKU_FORMAT_INFO vku_formats[{len(self.vk.formats) + 1}] = {{\n')
+        for f in formats_in_order.values():
             className = getClassName(f.className)
             blockExtent = ', '.join(f.blockExtent) if f.blockExtent is not None else '1, 1, 1'
-            out.extend(f'        case {f.name}: {{\n')
-            out.extend(f'            struct VKU_FORMAT_INFO out = {{VKU_FORMAT_COMPATIBILITY_CLASS_{className}, {f.blockSize}, {f.texelsPerBlock}, {{{blockExtent}}}, {len(f.components)}, {{')
+            out.extend(f'    {{ VKU_FORMAT_COMPATIBILITY_CLASS_{className}, {f.blockSize}, {f.texelsPerBlock}, {{{blockExtent}}}, {len(f.components)}, {{')
             for index, component in enumerate(f.components):
                 bits = 'VKU_FORMAT_COMPRESSED_COMPONENT' if component.bits == 'compressed' else component.bits
                 out.append(f'{{VKU_FORMAT_COMPONENT_TYPE_{component.type}, {bits}}}')
                 if index + 1 != len(f.components):
                     out.append(', ')
-            out.append('}};\n')
-            out.append('            return out; }\n')
-        out.append('''
-        default: {
-            // return values for VK_FORMAT_UNDEFINED
-            struct VKU_FORMAT_INFO out = { VKU_FORMAT_COMPATIBILITY_CLASS_NONE, 0, 0, {0, 0, 0}, 0, {{VKU_FORMAT_COMPONENT_TYPE_NONE, 0}, {VKU_FORMAT_COMPONENT_TYPE_NONE, 0}, {VKU_FORMAT_COMPONENT_TYPE_NONE, 0}, {VKU_FORMAT_COMPONENT_TYPE_NONE, 0}} };
-            return out;
-        }
-    };
+            out.append('} },\n')
+        out.append('};\n')
+
+        # Find the "format groups", eg formats whose value are consecutive, as that is the way they are written into the 'formats' array.
+        # Value refers to the enum value. These are discontinuous.
+        # Index refers to the index of a format in the vku_formats array. These are from 0 to the len(formats_in_order).
+        format_values = list(formats_in_order.keys())
+        FormatGroup = namedtuple('FormatGroup', ['begin_format', 'end_format','array_index'])
+        format_groups = []
+        index = 0
+        while index < len(format_values):
+            start_value = format_values[index]
+            end_value = format_values[-1] # use last format as sentinel so the last group can get the right end value
+            previous_value = start_value - 1
+            # Find the end value for the current group
+            for format_value in format_values[index:]:
+                if previous_value + 1 != format_value:
+                    end_value = previous_value
+                    break
+                previous_value = format_value
+            format_groups.append(FormatGroup(formats_in_order[start_value].name, formats_in_order[end_value].name, index))
+            index += (end_value - start_value) + 1
+
+        out.append('inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {\n')
+        for group in format_groups:
+            out.append(f'    {"else " if group.array_index != 0 else ""}if ({group.begin_format} <= format && format <= {group.end_format} )')
+            out.append(f' {{ return vku_formats[format - {group.begin_format} + {group.array_index}]; }}\n')
+        out.append('''    // Default case - return VK_FORMAT_UNDEFINED
+    else {
+        return vku_formats[0];
+    }
 }
 
 struct VKU_FORMAT_PER_PLANE_COMPATIBILITY {
@@ -555,52 +588,42 @@ inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspect
     return divisors;
 }
 
+// TODO - This should be generated, but will need updating the spec XML and table
+// Some few case don't have an aspect mask, so might need to check both the Depth and Stencil possiblity
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask) {
+    bool valid = false;
+
+    if (aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) {
+        if (ds_format == VK_FORMAT_S8_UINT || ds_format == VK_FORMAT_D16_UNORM_S8_UINT ||
+            ds_format == VK_FORMAT_D24_UNORM_S8_UINT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R8_UINT || color_format == VK_FORMAT_R8_SINT ||
+                      color_format == VK_FORMAT_R8_UNORM || color_format == VK_FORMAT_R8_SNORM);
+        }
+    }
+
+    if (aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) {
+        if (ds_format == VK_FORMAT_D32_SFLOAT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT ||
+            ds_format == VK_FORMAT_X8_D24_UNORM_PACK32 || ds_format == VK_FORMAT_D24_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT);
+        }
+        if (ds_format == VK_FORMAT_D16_UNORM || ds_format == VK_FORMAT_D16_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R16_SFLOAT || color_format == VK_FORMAT_R16_UNORM ||
+                      color_format == VK_FORMAT_R16_SNORM  || color_format == VK_FORMAT_R16_UINT || color_format == VK_FORMAT_R16_SINT);
+        }
+    }
+
+    return valid;
+}
+
 inline uint32_t vkuFormatComponentCount(VkFormat format) { return vkuGetFormatInfo(format).component_count; }
 
 inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetFormatInfo(format).block_extent; }
 
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format) { return vkuGetFormatInfo(format).compatibility; }
 
-inline bool vkuFormatElementIsTexel(VkFormat format) {
-    if (vkuFormatIsPacked(format) || vkuFormatIsCompressed(format) || vkuFormatIsSinglePlane_422(format) || vkuFormatIsMultiplane(format)) {
-        return false;
-    } else {
-        return true;
-    }
-}
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format) { return vkuGetFormatInfo(format).texels_per_block; }
 
-inline uint32_t vkuFormatElementSize(VkFormat format) {
-    return vkuFormatElementSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
-}
-
-inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
-    // Depth/Stencil aspect have separate helper functions
-    if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
-        return vkuFormatStencilSize(format) / 8;
-    } else if (aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
-        return vkuFormatDepthSize(format) / 8;
-    } else if (vkuFormatIsMultiplane(format)) {
-        // Element of entire multiplane format is not useful,
-        // Want to get just a single plane as the lookup format
-        format = vkuFindMultiplaneCompatibleFormat(format, aspectMask);
-    }
-
-    return vkuGetFormatInfo(format).block_size;
-}
-
-inline double vkuFormatTexelSize(VkFormat format) {
-    return vkuFormatTexelSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
-}
-
-inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
-    double texel_size = (double)(vkuFormatElementSizeWithAspect(format, aspectMask));
-    VkExtent3D block_extent = vkuFormatTexelBlockExtent(format);
-    uint32_t texels_per_block = block_extent.width * block_extent.height * block_extent.depth;
-    if (1 < texels_per_block) {
-        texel_size /= (double)(texels_per_block);
-    }
-    return texel_size;
-}
+inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
 
 ''')
         # Could loop the components, but faster to just list these

scripts/generators/generator_utils.py

@@ -1,25 +1,148 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
-# Copyright 2023 RasterGrid Kft.
+# Copyright (c) 2023-2024 Valve Corporation
+# Copyright (c) 2023-2024 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import os
+import sys
+import json
+
+# Build a set of all vuid text strings found in validusage.json
+def buildListVUID(valid_usage_file: str) -> set:
+
+    # Walk the JSON-derived dict and find all "vuid" key values
+    def ExtractVUIDs(vuid_dict):
+        if hasattr(vuid_dict, 'items'):
+            for key, value in vuid_dict.items():
+                if key == "vuid":
+                    yield value
+                elif isinstance(value, dict):
+                    for vuid in ExtractVUIDs(value):
+                        yield vuid
+                elif isinstance (value, list):
+                    for listValue in value:
+                        for vuid in ExtractVUIDs(listValue):
+                            yield vuid
+
+    valid_vuids = set()
+    if not os.path.isfile(valid_usage_file):
+        print(f'Error: Could not find, or error loading {valid_usage_file}')
+        sys.exit(1)
+    json_file = open(valid_usage_file, 'r', encoding='utf-8')
+    vuid_dict = json.load(json_file)
+    json_file.close()
+    if len(vuid_dict) == 0:
+        print(f'Error: Failed to load {valid_usage_file}')
+        sys.exit(1)
+    for json_vuid_string in ExtractVUIDs(vuid_dict):
+        valid_vuids.add(json_vuid_string)
+
+    # List of VUs that should exists, but have a spec bug
+    for vuid in [
+        # https://gitlab.khronos.org/vulkan/vulkan/-/issues/3582
+        "VUID-VkCopyImageToImageInfoEXT-commonparent",
+        "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parent",
+        "VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-parent",
+        "VUID-vkDestroyVideoSessionParametersKHR-videoSessionParameters-parent",
+        "VUID-vkGetDescriptorSetHostMappingVALVE-descriptorSet-parent",
+        ]:
+        valid_vuids.add(vuid)
+
+    return valid_vuids
+
+# Will do a sanity check the VUID exists
+def getVUID(valid_vuids: set, vuid: str, quotes: bool = True) -> str:
+    if vuid not in valid_vuids:
+        print(f'Warning: Could not find {vuid} in validusage.json')
+        vuid = vuid.replace('VUID-', 'UNASSIGNED-')
+    return vuid if not quotes else f'"{vuid}"'
+
 class PlatformGuardHelper():
     """Used to elide platform guards together, so redundant #endif then #ifdefs are removed
-    Note - be sure to call addGuard(None) when done to add a trailing #endif if needed
+    Note - be sure to call add_guard(None) when done to add a trailing #endif if needed
     """
     def __init__(self):
-        self.currentGuard = None
+        self.current_guard = None
 
-    def addGuard(self, guard):
+    def add_guard(self, guard, extra_newline = False):
         out = []
-        if self.currentGuard != guard:
-            if self.currentGuard != None:
-                out.append(f'#endif  // {self.currentGuard}\n')
-            if guard != None:
-                out.append(f'#ifdef {guard}\n')
-            self.currentGuard = guard
+        if self.current_guard != guard and self.current_guard is not None:
+            out.append(f'#endif  // {self.current_guard}\n')
+        if extra_newline:
+            out.append('\n')
+        if self.current_guard != guard and guard is not None:
+            out.append(f'#ifdef {guard}\n')
+        self.current_guard = guard
         return out
+
+# The SPIR-V grammar json doesn't have an easy way to detect these, so have listed by hand
+# If we are missing one, its not critical, the goal of this list is to reduce the generated output size
+def IsNonVulkanSprivCapability(capability):
+    return capability in [
+        'Kernel',
+        'Vector16',
+        'Float16Buffer',
+        'ImageBasic',
+        'ImageReadWrite',
+        'ImageMipmap',
+        'DeviceEnqueue',
+        'SubgroupDispatch',
+        'Pipes',
+        'LiteralSampler',
+        'NamedBarrier',
+        'PipeStorage',
+        'SubgroupShuffleINTEL',
+        'SubgroupShuffleINTEL',
+        'SubgroupBufferBlockIOINTEL',
+        'SubgroupImageBlockIOINTEL',
+        'SubgroupImageMediaBlockIOINTEL',
+        'RoundToInfinityINTEL',
+        'FloatingPointModeINTEL',
+        'IndirectReferencesINTEL',
+        'AsmINTEL',
+        'VectorComputeINTEL',
+        'VectorAnyINTEL',
+        'SubgroupAvcMotionEstimationINTEL',
+        'SubgroupAvcMotionEstimationIntraINTEL',
+        'SubgroupAvcMotionEstimationChromaINTEL',
+        'VariableLengthArrayINTEL',
+        'FunctionFloatControlINTEL',
+        'FPGAMemoryAttributesINTEL',
+        'FPFastMathModeINTEL',
+        'ArbitraryPrecisionIntegersINTEL',
+        'ArbitraryPrecisionFloatingPointINTEL',
+        'UnstructuredLoopControlsINTEL',
+        'FPGALoopControlsINTEL',
+        'KernelAttributesINTEL',
+        'FPGAKernelAttributesINTEL',
+        'FPGAMemoryAccessesINTEL',
+        'FPGAClusterAttributesINTEL',
+        'LoopFuseINTEL',
+        'FPGADSPControlINTEL',
+        'MemoryAccessAliasingINTEL',
+        'FPGAInvocationPipeliningAttributesINTEL',
+        'FPGABufferLocationINTEL',
+        'ArbitraryPrecisionFixedPointINTEL',
+        'USMStorageClassesINTEL',
+        'RuntimeAlignedAttributeINTEL',
+        'IOPipesINTEL',
+        'BlockingPipesINTEL',
+        'FPGARegINTEL',
+        'LongCompositesINTEL',
+        'OptNoneINTEL',
+        'DebugInfoModuleINTEL',
+        'BFloat16ConversionINTEL',
+        'SplitBarrierINTEL',
+        'FPGAClusterAttributesV2INTEL',
+        'FPGAKernelAttributesv2INTEL',
+        'FPMaxErrorINTEL',
+        'FPGALatencyControlINTEL',
+        'FPGAArgumentInterfacesINTEL',
+        'GlobalVariableHostAccessINTEL',
+        'GlobalVariableFPGADecorationsINTEL',
+        'MaskedGatherScatterINTEL',
+        'CacheControlsINTEL',
+        'RegisterLimitsINTEL'
+    ]

scripts/generators/safe_struct_generator.py

@@ -0,0 +1,813 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2025 The Khronos Group Inc.
+# Copyright (c) 2015-2025 Valve Corporation
+# Copyright (c) 2015-2025 LunarG, Inc.
+# Copyright (c) 2015-2025 Google Inc.
+# Copyright (c) 2023-2025 RasterGrid Kft.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import re
+from vulkan_object import Struct, Member
+from base_generator import BaseGenerator
+from generators.generator_utils import PlatformGuardHelper
+
+class SafeStructOutputGenerator(BaseGenerator):
+    def __init__(self):
+        BaseGenerator.__init__(self)
+
+        # Will skip completly, mainly used for things that have no one consuming the safe struct
+        self.no_autogen = [
+            # These WSI struct have nothing deep to copy, except the WSI releated field which we can't make a copy
+            'VkXlibSurfaceCreateInfoKHR',
+            'VkXcbSurfaceCreateInfoKHR',
+            'VkWaylandSurfaceCreateInfoKHR',
+            'VkAndroidSurfaceCreateInfoKHR',
+            'VkWin32SurfaceCreateInfoKHR',
+            'VkIOSSurfaceCreateInfoMVK',
+            'VkMacOSSurfaceCreateInfoMVK',
+            'VkMetalSurfaceCreateInfoEXT'
+        ]
+
+        # Will skip generating the source logic (to be implemented in vk_safe_struct_manual.cpp)
+        # The header will still be generated
+        self.manual_source = [
+            # This needs to know if we're doing a host or device build, logic becomes complex and very specialized
+            'VkAccelerationStructureBuildGeometryInfoKHR',
+            'VkAccelerationStructureGeometryKHR',
+            # Have a pUsageCounts and ppUsageCounts that is not currently handled in the generated code
+            'VkMicromapBuildInfoEXT',
+            'VkAccelerationStructureTrianglesOpacityMicromapEXT',
+            'VkAccelerationStructureTrianglesDisplacementMicromapNV',
+             # Special case because its pointers may be non-null but ignored
+            'VkGraphicsPipelineCreateInfo',
+            # Special case because it has custom construct parameters
+            'VkPipelineViewportStateCreateInfo',
+        ]
+
+        # For abstract types just want to save the pointer away
+        # since we cannot make a copy.
+        self.abstract_types = [
+            'AHardwareBuffer',
+            '_screen_context',
+            '_screen_window',
+            '_screen_buffer'
+        ]
+
+        # These 'data' union are decided by the 'type' in the same parent struct
+        self.union_of_pointers = [
+            'VkDescriptorDataEXT',
+            'VkIndirectCommandsTokenDataEXT',
+            'VkIndirectExecutionSetInfoEXT',
+        ]
+        self.union_of_pointer_callers = [
+            'VkDescriptorGetInfoEXT',
+        ]
+
+        # Will update the the function interface
+        self.custom_construct_params = {
+            # vku::safe::GraphicsPipelineCreateInfo needs to know if subpass has color and\or depth\stencil attachments to use its pointers
+            'VkGraphicsPipelineCreateInfo' :
+                ', const bool uses_color_attachment, const bool uses_depthstencil_attachment',
+            # vku::safe::PipelineViewportStateCreateInfo needs to know if viewport and scissor is dynamic to use its pointers
+            'VkPipelineViewportStateCreateInfo' :
+                ', const bool is_dynamic_viewports, const bool is_dynamic_scissors',
+            # vku::safe::AccelerationStructureBuildGeometryInfoKHR needs to know if we're doing a host or device build
+            'VkAccelerationStructureBuildGeometryInfoKHR' :
+                ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_infos',
+            # vku::safe::AccelerationStructureGeometryKHR needs to know if we're doing a host or device build
+            'VkAccelerationStructureGeometryKHR' :
+                ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_info',
+        }
+
+    def isInPnextChain(self, struct: Struct) -> bool:
+        # Can appear in VkPipelineCreateInfoKHR::pNext even though it isn't listed in the xml structextends attribute
+        # VUID-VkPipelineCreateInfoKHR-pNext-09604
+        pipeline_create_infos = [
+            'VkGraphicsPipelineCreateInfo',
+            'VkExecutionGraphPipelineCreateInfoAMDX',
+            'VkRayTracingPipelineCreateInfoKHR',
+            'VkComputePipelineCreateInfo',
+        ]
+        return struct.extends or struct.name in pipeline_create_infos
+
+    # Determine if a structure needs a safe_struct helper function
+    # That is, it has an sType or one of its members is a pointer
+    def needSafeStruct(self, struct: Struct) -> bool:
+        if struct.name in self.no_autogen:
+            return False
+        if struct.name in self.union_of_pointers:
+            return False
+        if 'VkBase' in struct.name:
+            return False #  Ingore structs like VkBaseOutStructure
+        if struct.sType is not None:
+            return True
+        for member in struct.members:
+            if member.pointer:
+                return True
+        # The VK_EXT_sample_locations design created edge case, easiest to handle here
+        if struct.name == 'VkAttachmentSampleLocationsEXT' or struct.name == 'VkSubpassSampleLocationsEXT':
+            return True
+        return False
+
+    def containsObjectHandle(self, member: Member) -> bool:
+        if member.type in self.vk.handles:
+            return True
+        if member.type in self.vk.structs:
+            for subMember in self.vk.structs[member.type].members:
+                if self.containsObjectHandle(subMember):
+                    return True
+        return False
+
+    def typeContainsObjectHandle(self, handle_type: str, dispatchable: bool) -> bool:
+        if handle_type in self.vk.handles:
+            if dispatchable == self.vk.handles[handle_type].dispatchable:
+                return True
+        # if handle_type is a struct, search its members
+        if handle_type in self.vk.structs:
+            struct = self.vk.structs[handle_type]
+            for member in [x for x in struct.members if x.type in self.vk.handles]:
+                if dispatchable == self.vk.handles[member.type].dispatchable:
+                    return True
+        return False
+
+    def generate(self):
+        # Should be fixed in 1.4.310 headers
+        # https://gitlab.khronos.org/vulkan/vulkan/-/merge_requests/7196
+        manual_protect = ["VkCudaModuleNV", "VkCudaFunctionNV", "VkCudaModuleCreateInfoNV", "VkCudaFunctionCreateInfoNV", "VkCudaLaunchInfoNV", "VkPhysicalDeviceCudaKernelLaunchFeaturesNV", "VkPhysicalDeviceCudaKernelLaunchPropertiesNV", "VkSetPresentConfigNV", "VkPhysicalDevicePresentMeteringFeaturesNV"]
+        for struct in [x for x in self.vk.structs.values() if x.name in manual_protect]:
+            struct.protect = "VK_ENABLE_BETA_EXTENSIONS"
+
+        self.write(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+            // See {os.path.basename(__file__)} for modifications
+
+            /***************************************************************************
+            *
+            * Copyright (c) 2015-2025 The Khronos Group Inc.
+            * Copyright (c) 2015-2025 Valve Corporation
+            * Copyright (c) 2015-2025 LunarG, Inc.
+            * Copyright (c) 2015-2025 Google Inc.
+            *
+            * SPDX-License-Identifier: Apache-2.0
+            *
+            ****************************************************************************/\n''')
+        self.write('// NOLINTBEGIN') # Wrap for clang-tidy to ignore
+
+        if self.filename == 'vk_safe_struct.hpp':
+            self.generateHeader()
+        elif self.filename == 'vk_safe_struct_utils.cpp':
+            self.generateUtil()
+        elif self.filename.startswith('vk_safe_struct_'):
+            self.generateSource()
+        else:
+            self.write(f'\nFile name {self.filename} has no code to generate\n')
+
+        self.write('// NOLINTEND') # Wrap for clang-tidy to ignore
+
+    def convertName(self, vk_name):
+        return "safe_" + vk_name
+
+    def generateHeader(self):
+        out = []
+        out.append('''
+            #pragma once
+            #include <vulkan/vulkan.h>
+            #include <algorithm>
+
+            #include <vulkan/utility/vk_safe_struct_utils.hpp>
+
+            namespace vku {
+
+            // Mapping of unknown stype codes to structure lengths. This should be set up by the application
+            // before vkCreateInstance() and not modified afterwards.
+            std::vector<std::pair<uint32_t, uint32_t>>& GetCustomStypeInfo();
+            \n''')
+
+        guard_helper = PlatformGuardHelper()
+        for struct in [x for x in self.vk.structs.values() if self.needSafeStruct(x)]:
+            safe_name = self.convertName(struct.name)
+            out.extend(guard_helper.add_guard(struct.protect))
+            out.append(f'{"union" if struct.union else "struct"} {safe_name} {{\n')
+            # Can only initialize first member of an Union
+            canInitialize = True
+            copy_pnext = ', bool copy_pnext = true' if struct.sType is not None else ''
+            for member in struct.members:
+                if member.type in self.vk.structs:
+                    if self.needSafeStruct(self.vk.structs[member.type]):
+                        safe_member_type = self.convertName(member.type)
+                        if member.pointer:
+                            pointer = '*' * member.cDeclaration.count('*')
+                            brackets = '' if struct.union else '{}'
+                            out.append(f'{safe_member_type}{pointer} {member.name}{brackets};\n')
+                        else:
+                            out.append(f'{safe_member_type} {member.name};\n')
+                        continue
+
+                explicitInitialize = member.pointer  and 'PFN_' not in member.type and canInitialize
+                initialize = '{}' if explicitInitialize else ''
+                # Prevents union from initializing agian
+                canInitialize = not struct.union if explicitInitialize else canInitialize
+
+                if member.length and self.containsObjectHandle(member) and not member.fixedSizeArray:
+                    out.append(f'    {member.type}* {member.name}{initialize};\n')
+                else:
+                    out.append(f'{member.cDeclaration}{initialize};\n')
+
+            constructParam = self.custom_construct_params.get(struct.name, '')
+            out.append(f'''
+                {safe_name}(const {struct.name}* in_struct{constructParam}, PNextCopyState* copy_state = {{}}{copy_pnext});
+                {safe_name}(const {safe_name}& copy_src);
+                {safe_name}& operator=(const {safe_name}& copy_src);
+                {safe_name}();
+                ~{safe_name}();
+                void initialize(const {struct.name}* in_struct{constructParam}, PNextCopyState* copy_state = {{}});
+                void initialize(const {safe_name}* copy_src, PNextCopyState* copy_state = {{}});
+                {struct.name} *ptr() {{ return reinterpret_cast<{struct.name} *>(this); }}
+                {struct.name} const *ptr() const {{ return reinterpret_cast<{struct.name} const *>(this); }}
+                ''')
+
+            if struct.name == 'VkShaderModuleCreateInfo':
+                out.append('''
+                    // Primarily intended for use by GPUAV when replacing shader module code with instrumented code
+                    template<typename Container>
+                    void SetCode(const Container &code) {
+                        delete[] pCode;
+                        codeSize = static_cast<uint32_t>(code.size() * sizeof(uint32_t));
+                        pCode = new uint32_t[code.size()];
+                        std::copy(&code.front(), &code.back() + 1, const_cast<uint32_t*>(pCode));
+                    }
+                    ''')
+            out.append('};\n')
+        out.extend(guard_helper.add_guard(None))
+
+        out.append('''
+                // Safe struct that spans NV and KHR VkRayTracingPipelineCreateInfo structures.
+                // It is a VkRayTracingPipelineCreateInfoKHR and supports construction from
+                // a VkRayTracingPipelineCreateInfoNV.
+                class safe_VkRayTracingPipelineCreateInfoCommon : public safe_VkRayTracingPipelineCreateInfoKHR {
+                public:
+                    safe_VkRayTracingPipelineCreateInfoCommon() : safe_VkRayTracingPipelineCreateInfoKHR() {}
+                    safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoNV *pCreateInfo)
+                        : safe_VkRayTracingPipelineCreateInfoKHR() {
+                        initialize(pCreateInfo);
+                    }
+                    safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoKHR *pCreateInfo)
+                        : safe_VkRayTracingPipelineCreateInfoKHR(pCreateInfo) {}
+
+                    void initialize(const VkRayTracingPipelineCreateInfoNV *pCreateInfo);
+                    void initialize(const VkRayTracingPipelineCreateInfoKHR *pCreateInfo);
+                    uint32_t maxRecursionDepth = 0;  // NV specific
+                };
+                ''')
+        out.append('''
+            } // namespace vku
+        ''')
+        self.write("".join(out))
+
+    def generateUtil(self):
+        out = []
+        out.append('''
+            #include <vulkan/vk_layer.h>
+            #include <vulkan/utility/vk_safe_struct.hpp>
+
+            #include <vector>
+            #include <cstring>
+
+            namespace vku {
+            char *SafeStringCopy(const char *in_string) {
+                if (nullptr == in_string) return nullptr;
+                size_t len = std::strlen(in_string);
+                char* dest = new char[len + 1];
+                dest[len] = '\\0';
+                std::memcpy(dest, in_string, len);
+                return dest;
+            }
+
+            ''')
+        out.append('''
+// clang-format off
+void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
+    void *first_pNext{};
+    VkBaseOutStructure *prev_pNext{};
+    void *safe_pNext{};
+
+    while (pNext) {
+        const VkBaseOutStructure *header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
+
+        switch (header->sType) {
+            // Add special-case code to copy beloved secret loader structs
+            // Special-case Loader Instance Struct passed to/from layer in pNext chain
+            case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: {
+                VkLayerInstanceCreateInfo *struct_copy = new VkLayerInstanceCreateInfo;
+                // TODO: Uses original VkLayerInstanceLink* chain, which should be okay for our uses
+                memcpy(struct_copy, pNext, sizeof(VkLayerInstanceCreateInfo));
+                safe_pNext = struct_copy;
+                break;
+            }
+            // Special-case Loader Device Struct passed to/from layer in pNext chain
+            case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: {
+                VkLayerDeviceCreateInfo *struct_copy = new VkLayerDeviceCreateInfo;
+                // TODO: Uses original VkLayerDeviceLink*, which should be okay for our uses
+                memcpy(struct_copy, pNext, sizeof(VkLayerDeviceCreateInfo));
+                safe_pNext = struct_copy;
+                break;
+            }
+''')
+        guard_helper = PlatformGuardHelper()
+        for struct in filter(self.isInPnextChain, self.vk.structs.values()):
+            safe_name = self.convertName(struct.name)
+            out.extend(guard_helper.add_guard(struct.protect))
+            out.append(f'            case {struct.sType}:\n')
+            out.append(f'                safe_pNext = new {safe_name}(reinterpret_cast<const {struct.name} *>(pNext), copy_state, false);\n')
+            out.append('                break;\n')
+        out.extend(guard_helper.add_guard(None))
+
+        out.append('''
+            default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain
+                // If sType is in custom list, construct blind copy
+                for (auto item : GetCustomStypeInfo()) {
+                    if (item.first == static_cast<uint32_t>(header->sType)) {
+                        safe_pNext = malloc(item.second);
+                        memcpy(safe_pNext, header, item.second);
+                    }
+                }
+                break;
+        }
+        if (!first_pNext) {
+            first_pNext = safe_pNext;
+        }
+        pNext = header->pNext;
+        if (prev_pNext && safe_pNext) {
+            prev_pNext->pNext = (VkBaseOutStructure*)safe_pNext;
+        }
+        if (safe_pNext) {
+            prev_pNext = (VkBaseOutStructure*)safe_pNext;
+        }
+        safe_pNext = nullptr;
+    }
+
+    return first_pNext;
+}
+
+void FreePnextChain(const void *pNext) {
+    // The pNext parameter is const for convenience, since it is called by code
+    // for many structures where the pNext field is const.
+    void *current = const_cast<void*>(pNext);
+    while (current) {
+        auto header = reinterpret_cast<VkBaseOutStructure *>(current);
+        void *next = header->pNext;
+        // prevent destructors from recursing behind our backs.
+        header->pNext = nullptr;
+
+        switch (header->sType) {
+            // Special-case Loader Instance Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
+            delete reinterpret_cast<VkLayerInstanceCreateInfo *>(current);
+            break;
+        // Special-case Loader Device Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
+            delete reinterpret_cast<VkLayerDeviceCreateInfo *>(current);
+            break;
+''')
+
+        for struct in filter(self.isInPnextChain, self.vk.structs.values()):
+            safe_name = self.convertName(struct.name)
+            out.extend(guard_helper.add_guard(struct.protect))
+            out.append(f'        case {struct.sType}:\n')
+            out.append(f'            delete reinterpret_cast<{safe_name} *>(header);\n')
+            out.append('            break;\n')
+        out.extend(guard_helper.add_guard(None))
+
+        out.append('''
+        default: // Encountered an unknown sType
+            // If sType is in custom list, free custom struct memory and clean up
+            for (auto item : GetCustomStypeInfo()   ) {
+                if (item.first == static_cast<uint32_t>(header->sType)) {
+                    free(current);
+                    break;
+                }
+            }
+            break;
+        }
+        current = next;
+    }
+}''')
+        out.append('// clang-format on\n')
+        out.append('''
+            } // namespace vku
+        ''')
+        self.write("".join(out))
+
+    def generateSource(self):
+        out = []
+        out.append('''
+            #include <vulkan/utility/vk_safe_struct.hpp>
+            #include <vulkan/utility/vk_struct_helper.hpp>
+
+            #include <cstddef>
+            #include <cstring>
+
+            namespace vku {
+            ''')
+
+        custom_defeault_construct_txt = {}
+
+        custom_construct_txt = {
+                # VkWriteDescriptorSet is special case because pointers may be non-null but ignored
+                'VkWriteDescriptorSet' : '''
+                    switch (descriptorType) {
+                        case VK_DESCRIPTOR_TYPE_SAMPLER:
+                        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+                        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+                        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+                        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+                        case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
+                        case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM:
+                        if (descriptorCount && in_struct->pImageInfo) {
+                            pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+                            for (uint32_t i = 0; i < descriptorCount; ++i) {
+                                pImageInfo[i] = in_struct->pImageInfo[i];
+                            }
+                        }
+                        break;
+                        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+                        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+                        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+                        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+                        if (descriptorCount && in_struct->pBufferInfo) {
+                            pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+                            for (uint32_t i = 0; i < descriptorCount; ++i) {
+                                pBufferInfo[i] = in_struct->pBufferInfo[i];
+                            }
+                        }
+                        break;
+                        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+                        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+                        if (descriptorCount && in_struct->pTexelBufferView) {
+                            pTexelBufferView = new VkBufferView[descriptorCount];
+                            for (uint32_t i = 0; i < descriptorCount; ++i) {
+                                pTexelBufferView[i] = in_struct->pTexelBufferView[i];
+                            }
+                        }
+                        break;
+                        default:
+                        break;
+                    }
+                ''',
+                'VkShaderModuleCreateInfo' : '''
+                    if (in_struct->pCode) {
+                        pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
+                        memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);
+                    }
+                ''',
+                # VkFrameBufferCreateInfo is special case because its pAttachments pointer may be non-null but ignored
+                'VkFramebufferCreateInfo' : '''
+                    if (attachmentCount && in_struct->pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) {
+                        pAttachments = new VkImageView[attachmentCount];
+                        for (uint32_t i = 0; i < attachmentCount; ++i) {
+                            pAttachments[i] = in_struct->pAttachments[i];
+                        }
+                    }
+                ''',
+                # VkDescriptorSetLayoutBinding is special case because its pImmutableSamplers pointer may be non-null but ignored
+                'VkDescriptorSetLayoutBinding' : '''
+                    const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+                    if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {
+                        pImmutableSamplers = new VkSampler[descriptorCount];
+                        for (uint32_t i = 0; i < descriptorCount; ++i) {
+                            pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
+                        }
+                    }
+                ''',
+                'VkPipelineRenderingCreateInfo': '''
+                    bool custom_init = copy_state && copy_state->init;
+                    if (custom_init) {
+                        custom_init = copy_state->init(reinterpret_cast<VkBaseOutStructure*>(this), reinterpret_cast<const VkBaseOutStructure*>(in_struct));
+                    }
+                    if (!custom_init) {
+                        // The custom iniitalization was not used, so do the regular initialization
+                        if (in_struct->pColorAttachmentFormats) {
+                            pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+                            memcpy ((void *)pColorAttachmentFormats, (void *)in_struct->pColorAttachmentFormats, sizeof(VkFormat)*in_struct->colorAttachmentCount);
+                        }
+                    }
+                ''',
+                # TODO: VkPushDescriptorSetWithTemplateInfo needs a custom constructor to handle pData
+                # https://github.com/KhronosGroup/Vulkan-Utility-Libraries/issues/193
+                'VkPushDescriptorSetWithTemplateInfo': '''
+                ''',
+            }
+
+        custom_copy_txt = {
+                'VkFramebufferCreateInfo' : '''
+                    pNext = SafePnextCopy(copy_src.pNext);
+                    if (attachmentCount && copy_src.pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) {
+                        pAttachments = new VkImageView[attachmentCount];
+                        for (uint32_t i = 0; i < attachmentCount; ++i) {
+                            pAttachments[i] = copy_src.pAttachments[i];
+                        }
+                    }
+                ''',
+                'VkPipelineRenderingCreateInfo': '''
+                    if (copy_src.pColorAttachmentFormats) {
+                        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+                        memcpy ((void *)pColorAttachmentFormats, (void *)copy_src.pColorAttachmentFormats, sizeof(VkFormat)*copy_src.colorAttachmentCount);
+                    }
+                '''
+            }
+
+        custom_destruct_txt = {
+                'VkShaderModuleCreateInfo' : '''
+                    if (pCode)
+                        delete[] reinterpret_cast<const uint8_t *>(pCode);
+                ''',
+            }
+
+        member_init_transforms = {
+            'queueFamilyIndexCount': lambda m: f'{m.name}(0)'
+        }
+
+        def qfi_construct(item, member):
+            true_index_setter = lambda i: f'{i}queueFamilyIndexCount = in_struct->queueFamilyIndexCount;\n'
+            false_index_setter = lambda i: f'{i}queueFamilyIndexCount = 0;\n'
+            if item.name == 'VkSwapchainCreateInfoKHR':
+                return (f'(in_struct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->{member.name}', true_index_setter, false_index_setter)
+            else:
+                return (f'(in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->{member.name}', true_index_setter, false_index_setter)
+
+        # map of:
+        #  <member name>: function(item, member) -> (condition, true statement, false statement)
+        member_construct_conditions = {
+            'pQueueFamilyIndices': qfi_construct
+        }
+
+        # Find what types of safe structs need to be generated based on output file name
+        splitRegex = r'.*';
+        if self.filename.endswith('_khr.cpp'):
+            splitRegex = r'.*KHR$'
+        elif self.filename.endswith('_ext.cpp'):
+            splitRegex = r'.*EXT$'
+        elif self.filename.endswith('_vendor.cpp'):
+            splitRegex = r'^(?!.*(KHR|EXT)$).*[A-Z]$' # Matches all words finishing with an upper case letter, but not ending with KHRor EXT
+        else: # elif self.filename.endswith('_core.cpp'):
+            splitRegex = r'.*[a-z0-9]$'
+
+        guard_helper = PlatformGuardHelper()
+
+        for struct in [x for x in self.vk.structs.values() if self.needSafeStruct(x) and x.name not in self.manual_source and re.match(splitRegex, x.name)]:
+            out.extend(guard_helper.add_guard(struct.protect))
+
+            init_list = ''          # list of members in struct constructor initializer
+            default_init_list = ''  # Default constructor just inits ptrs to nullptr in initializer
+            init_func_txt = ''      # Txt for initialize() function that takes struct ptr and inits members
+            construct_txt = ''      # Body of constuctor as well as body of initialize() func following init_func_txt
+            destruct_txt = ''
+
+            has_pnext = struct.sType is not None
+            copy_pnext = ''
+            copy_pnext_if = ''
+            copy_strings = ''
+            for member in struct.members:
+                m_type = member.type
+                m_type_safe = False
+                if member.name == 'pNext':
+                    copy_pnext = 'pNext = SafePnextCopy(in_struct->pNext, copy_state);\n'
+                    copy_pnext_if = '''
+                    if (copy_pnext) {
+                        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+                    }'''
+                if member.type in self.vk.structs and self.needSafeStruct(self.vk.structs[member.type]):
+                    m_type = self.convertName(member.type)
+                    m_type_safe = True;
+
+                if member.pointer and not m_type_safe and 'PFN_' not in member.type and not self.typeContainsObjectHandle(member.type, False):
+                    # Ptr types w/o a safe_struct, for non-null case need to allocate new ptr and copy data in
+                    if m_type in ['void', 'char']:
+                        if member.name != 'pNext':
+                            if m_type == 'char':
+                                # Create deep copies of strings
+                                if member.length:
+                                    copy_strings += f'''
+                                        char **tmp_{member.name} = new char *[in_struct->{member.length}];
+                                        for (uint32_t i = 0; i < {member.length}; ++i) {{
+                                            tmp_{member.name}[i] = SafeStringCopy(in_struct->{member.name}[i]);
+                                        }}
+                                        {member.name} = tmp_{member.name};'''
+
+                                    destruct_txt += f'''
+                                        if ({member.name}) {{
+                                            for (uint32_t i = 0; i < {member.length}; ++i) {{
+                                                delete [] {member.name}[i];
+                                            }}
+                                            delete [] {member.name};
+                                        }}'''
+                                else:
+                                    copy_strings += f'{member.name} = SafeStringCopy(in_struct->{member.name});\n'
+                                    destruct_txt += f'if ({member.name}) delete [] {member.name};\n'
+                            else:
+                                # We need a deep copy of pData / dataSize combos
+                                if member.name == 'pData':
+                                    init_list += f'\n    {member.name}(nullptr),'
+                                    construct_txt += '''
+                                        if (in_struct->pData != nullptr) {
+                                            auto temp = new std::byte[in_struct->dataSize];
+                                            std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+                                            pData = temp;
+                                        }
+                                        '''
+
+                                    destruct_txt  += '''
+                                        if (pData != nullptr) {
+                                            auto temp = reinterpret_cast<const std::byte*>(pData);
+                                            delete [] temp;
+                                        }
+                                        '''
+                                else:
+                                    init_list += f'\n{member.name}(in_struct->{member.name}),'
+                                    init_func_txt += f'{member.name} = in_struct->{member.name};\n'
+                        default_init_list += f'\n{member.name}(nullptr),'
+                    else:
+                        default_init_list += f'\n{member.name}(nullptr),'
+                        init_list += f'\n{member.name}(nullptr),'
+                        if m_type in self.abstract_types:
+                            construct_txt += f'{member.name} = in_struct->{member.name};\n'
+                        else:
+                            init_func_txt += f'{member.name} = nullptr;\n'
+                            if not member.fixedSizeArray and (member.length is None or '/' in member.length):
+                                construct_txt += f'''
+                                    if (in_struct->{member.name}) {{
+                                            {member.name} = new {m_type}(*in_struct->{member.name});
+                                        }}
+                                    '''
+                                destruct_txt += f'if ({member.name})\n'
+                                destruct_txt += f'    delete {member.name};\n'
+                            else:
+                                # Prepend struct members with struct name
+                                decorated_length = member.length
+                                for other_member in struct.members:
+                                    decorated_length = re.sub(r'\b({})\b'.format(other_member.name), r'in_struct->\1', decorated_length)
+                                try:
+                                    concurrent_clause = member_construct_conditions[member.name](struct, member)
+                                except:
+                                    concurrent_clause = (f'in_struct->{member.name}', lambda x: '')
+                                construct_txt += f'''
+                                    if ({concurrent_clause[0]}) {{
+                                        {member.name} = new {m_type}[{decorated_length}];
+                                        memcpy ((void *){member.name}, (void *)in_struct->{member.name}, sizeof({m_type})*{decorated_length});
+                                        {concurrent_clause[1]('        ')}'''
+                                if len(concurrent_clause) > 2:
+                                    construct_txt += '} else {\n'
+                                    construct_txt += concurrent_clause[2]('        ')
+                                construct_txt += '}\n'
+                                destruct_txt += f'if ({member.name})\n'
+                                destruct_txt += f'    delete[] {member.name};\n'
+                elif member.fixedSizeArray or member.length is not None:
+                    if member.fixedSizeArray:
+                        construct_txt += f'''
+                            for (uint32_t i = 0; i < {member.fixedSizeArray[0]}; ++i) {{
+                                    {member.name}[i] = in_struct->{member.name}[i];
+                                }}
+                            '''
+                    else:
+                        # Init array ptr to NULL
+                        default_init_list += f'\n{member.name}(nullptr),'
+                        init_list += f'\n{member.name}(nullptr),'
+                        init_func_txt += f'{member.name} = nullptr;\n'
+                        array_element = f'in_struct->{member.name}[i]'
+                        if member.type in self.vk.structs and self.needSafeStruct(self.vk.structs[member.type]):
+                            array_element = f'{member.type}(&in_struct->safe_{member.name}[i])'
+                        construct_txt += f'if ({member.length} && in_struct->{member.name}) {{\n'
+                        construct_txt += f'    {member.name} = new {m_type}[{member.length}];\n'
+                        destruct_txt += f'if ({member.name})\n'
+                        destruct_txt += f'    delete[] {member.name};\n'
+                        construct_txt += f'for (uint32_t i = 0; i < {member.length}; ++i) {{\n'
+                        if m_type_safe:
+                            construct_txt += f'{member.name}[i].initialize(&in_struct->{member.name}[i]);\n'
+                        else:
+                            construct_txt += f'{member.name}[i] = {array_element};\n'
+                        construct_txt += '}\n'
+                        construct_txt += '}\n'
+                elif member.pointer and 'PFN_' not in member.type:
+                    default_init_list += f'\n{member.name}(nullptr),'
+                    init_list += f'\n{member.name}(nullptr),'
+                    init_func_txt += f'{member.name} = nullptr;\n'
+                    construct_txt += f'if (in_struct->{member.name})\n'
+                    construct_txt += f'    {member.name} = new {m_type}(in_struct->{member.name});\n'
+                    destruct_txt += f'if ({member.name})\n'
+                    destruct_txt += f'    delete {member.name};\n'
+                elif m_type_safe and member.type in self.union_of_pointers:
+                    init_list += f'\n{member.name}(&in_struct->{member.name}, in_struct->type),'
+                    init_func_txt += f'{member.name}.initialize(&in_struct->{member.name}, in_struct->type);\n'
+                elif m_type_safe:
+                    init_list += f'\n{member.name}(&in_struct->{member.name}),'
+                    init_func_txt += f'{member.name}.initialize(&in_struct->{member.name});\n'
+                else:
+                    try:
+                        init_list += f'\n{member_init_transforms[member.name](member)},'
+                    except:
+                        init_list += f'\n{member.name}(in_struct->{member.name}),'
+                        init_func_txt += f'{member.name} = in_struct->{member.name};\n'
+                    if not struct.union:
+                        if member.name == 'sType' and struct.sType:
+                            default_init_list += f'\n{member.name}({struct.sType}),'
+                        else:
+                            default_init_list += f'\n{member.name}(),'
+            if '' != init_list:
+                init_list = init_list[:-1] # hack off final comma
+
+            if struct.name in custom_construct_txt:
+                construct_txt = custom_construct_txt[struct.name]
+
+            construct_txt = copy_strings + construct_txt
+
+            if struct.name in custom_destruct_txt:
+                destruct_txt = custom_destruct_txt[struct.name]
+
+            copy_pnext_param = ''
+            if has_pnext:
+                copy_pnext_param = ', bool copy_pnext'
+                destruct_txt += '    FreePnextChain(pNext);\n'
+
+            safe_name = self.convertName(struct.name)
+            if struct.union:
+                # Unions don't allow multiple members in the initialization list, so just call initialize
+                out.append(f'''
+                    {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, PNextCopyState*)
+                    {{
+                        initialize(in_struct);
+                    }}
+                    ''')
+            else:
+                out.append(f'''
+                    {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state{copy_pnext_param}) :{init_list}
+                    {{
+                    {copy_pnext_if + construct_txt}}}
+                    ''')
+            if '' != default_init_list:
+                # trim trailing comma from initializer list
+                default_init_list = f' :{default_init_list[:-1]}'
+                # truncate union initializer list to first element
+                if struct.union:
+                    default_init_list = default_init_list.split(',')[0]
+            default_init_body = '\n' + custom_defeault_construct_txt[struct.name] if struct.name in custom_defeault_construct_txt else ''
+            out.append(f'''
+                {safe_name}::{safe_name}(){default_init_list}
+                {{{default_init_body}}}
+                ''')
+            # Create slight variation of init and construct txt for copy constructor that takes a copy_src object reference vs. struct ptr
+            construct_txt = copy_pnext + construct_txt
+            copy_construct_init = init_func_txt.replace('in_struct->', 'copy_src.')
+            copy_construct_init = copy_construct_init.replace(', copy_state', '')
+            if struct.name in self.union_of_pointer_callers:
+                copy_construct_init = copy_construct_init.replace(', copy_src.type', '')
+            # Pass object to copy constructors
+            copy_construct_txt = re.sub('(new \\w+)\\(in_struct->', '\\1(*copy_src.', construct_txt)
+            # Modify remaining struct refs for copy_src object
+            copy_construct_txt = copy_construct_txt.replace('in_struct->', 'copy_src.')
+            # Modify remaining struct refs for copy_src object
+            copy_construct_txt = copy_construct_txt .replace(', copy_state', '')
+            if struct.name in custom_copy_txt:
+                copy_construct_txt = custom_copy_txt[struct.name]
+            copy_assign_txt = '    if (&copy_src == this) return *this;\n\n' + destruct_txt + '\n' + copy_construct_init + copy_construct_txt + '\n    return *this;'
+            # Copy constructor
+            out.append(f'''
+                {safe_name}::{safe_name}(const {safe_name}& copy_src)
+                {{
+                {copy_construct_init}{copy_construct_txt}}}
+                ''')
+            # Copy assignment operator
+            out.append(f'''
+                {safe_name}& {safe_name}::operator=(const {safe_name}& copy_src)\n{{
+                {copy_assign_txt}
+                }}
+                ''')
+            out.append(f'''
+                {safe_name}::~{safe_name}()
+                {{
+                {destruct_txt}}}
+                ''')
+            out.append(f'''
+                void {safe_name}::initialize(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state)
+                {{
+                {destruct_txt}{init_func_txt}{construct_txt}}}
+                ''')
+            # Copy initializer uses same txt as copy constructor but has a ptr and not a reference
+            init_copy = copy_construct_init.replace('copy_src.', 'copy_src->')
+            # Replace '&copy_src' with 'copy_src' unless it's followed by a dereference
+            init_copy = re.sub(r'&copy_src(?!->)', 'copy_src', init_copy)
+            init_construct = copy_construct_txt.replace('copy_src.', 'copy_src->')
+            # Replace '&copy_src' with 'copy_src' unless it's followed by a dereference
+            init_construct = re.sub(r'&copy_src(?!->)', 'copy_src', init_construct)
+            out.append(f'''
+                void {safe_name}::initialize(const {safe_name}* copy_src, [[maybe_unused]] PNextCopyState* copy_state)
+                {{
+                {init_copy}{init_construct}}}
+                ''')
+        out.extend(guard_helper.add_guard(None))
+        out.append('''
+            } // namespace vku
+        ''')
+
+        self.write("".join(out))

scripts/generators/struct_helper_generator.py

@@ -19,7 +19,7 @@
 # limitations under the License.
 
 import os
-from generators.base_generator import BaseGenerator
+from base_generator import BaseGenerator
 from generators.generator_utils import PlatformGuardHelper
 
 class StructHelperOutputGenerator(BaseGenerator):
@@ -53,9 +53,9 @@ VkStructureType GetSType() {
         guard_helper = PlatformGuardHelper()
 
         for struct in [x for x in self.vk.structs.values() if x.sType]:
-            out.extend(guard_helper.addGuard(struct.protect))
+            out.extend(guard_helper.add_guard(struct.protect))
             out.append(f'template <> inline VkStructureType GetSType<{struct.name}>() {{ return {struct.sType}; }}\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('''
 // Find an entry of the given type in the const pNext chain
 // returns nullptr if the entry is not found
@@ -123,20 +123,24 @@ class InitStructHelper {
         return InitStruct<T>(p_next);
     }
 };
-
+#if VK_USE_64_BIT_PTR_DEFINES == 1
 template<typename T> VkObjectType GetObjectType() {
     static_assert(sizeof(T) == 0, "GetObjectType() is being used with an unsupported Type! Is the code-gen up to date?");
     return VK_OBJECT_TYPE_UNKNOWN;
 }
 
-#if VK_USE_64_BIT_PTR_DEFINES == 1
 ''')
         for handle in self.vk.handles.values():
-            out.extend(guard_helper.addGuard(handle.protect))
+            out.extend(guard_helper.add_guard(handle.protect))
             out.append(f'template<> inline VkObjectType GetObjectType<{handle.name}>() {{ return {handle.type}; }}\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('''
-#endif // VK_USE_64_BIT_PTR_DEFINES == 1
+# else // 32 bit
+template<typename T> VkObjectType GetObjectType() {
+    static_assert(sizeof(T) == 0, "GetObjectType() does not support 32 bit builds! This is a limitation of the vulkan.h headers");
+    return VK_OBJECT_TYPE_UNKNOWN;
+}
+# endif // VK_USE_64_BIT_PTR_DEFINES == 1
 } // namespace vku
 \n''')
 

scripts/generators/vulkan_object.py

@@ -1,377 +0,0 @@
-#!/usr/bin/python3 -i
-#
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from dataclasses import dataclass, field
-from enum import IntFlag, Enum, auto
-
-@dataclass
-class Extension:
-    """<extension>"""
-    name: str # ex) VK_KHR_SURFACE
-    nameString: str # marco with string, ex) VK_KHR_SURFACE_EXTENSION_NAME
-
-    # Only one will be True, the other is False
-    instance: bool
-    device: bool
-
-    depends: (str | None)
-    vendorTag: (str | None)  # ex) EXT, KHR, etc
-    platform: (str | None)   # ex) android
-    protect: (str | None)    # ex) VK_USE_PLATFORM_ANDROID_KHR
-    provisional: bool
-    promotedTo: (str | None) # ex) VK_VERSION_1_1
-    deprecatedBy: (str | None)
-    obsoletedBy: (str | None)
-    specialUse: list[str]
-
-    # These are here to allow for easy reverse lookups
-    # Quotes allow us to forward declare the dataclass
-    commands: list['Command'] = field(default_factory=list, init=False)
-    enums:    list['Enum']    = field(default_factory=list, init=False)
-    bitmask:  list['Bitmask'] = field(default_factory=list, init=False)
-    # Use the Enum name to see what fields are extended
-    enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False)
-    # Use the Bitmaks name to see what flags are extended
-    flags: dict[str, list['Flag']] = field(default_factory=dict, init=False)
-
-@dataclass
-class Version:
-    """
-    <feature> which represents a version
-    This will NEVER be Version 1.0, since having 'no version' is same as being 1.0
-    """
-    name: str       # ex) VK_VERSION_1_1
-    nameString: str # ex) "VK_VERSION_1_1" (no marco, so has quotes)
-    nameApi: str    # ex) VK_API_VERSION_1_1
-    number: str     # ex) 1.1
-
-@dataclass
-class Handle:
-    """<type> which represents a dispatch handle"""
-    name: str # ex) VkBuffer
-    type: str # ex) VK_OBJECT_TYPE_BUFFER
-    protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR
-
-    parent: 'Handle' # Chain of parent handles, can be None
-
-    # Only one will be True, the other is False
-    instance: bool
-    device: bool
-
-    dispatchable: bool
-
-@dataclass
-class Param:
-    """<command/param>"""
-    name: str
-    alias: str
-    type: str # ex) void, VkFormat, etc
-
-    noAutoValidity: bool
-
-    const: bool           # type contains 'const'
-    length:  (str | None) # the known length of pointer, will never be 'null-terminated'
-    nullTerminated: bool  # If a UTF-8 string, it will be null-terminated
-    pointer: bool         # type contains a pointer (include 'PFN' function pointers)
-    fixedSizeArray: list[str] # for VkTransformMatrixKHR:matrix this is [3, 4]
-
-    optional: bool
-    optionalPointer: bool # if type contains a pointer, is the pointer value optional
-
-    externSync: bool
-    externSyncPointer: list[str] # if type contains a pointer, might only specific members modified
-
-    # C string of member, example:
-    #   - const void* pNext
-    #   - VkFormat format
-    #   - VkStructureType sType
-    cDeclaration: str
-
-class Queues(IntFlag):
-    TRANSFER       = auto() # VK_QUEUE_TRANSFER_BIT
-    GRAPHICS       = auto() # VK_QUEUE_GRAPHICS_BIT
-    COMPUTE        = auto() # VK_QUEUE_COMPUTE_BIT
-    PROTECTED      = auto() # VK_QUEUE_PROTECTED_BIT
-    SPARSE_BINDING = auto() # VK_QUEUE_SPARSE_BINDING_BIT
-    OPTICAL_FLOW   = auto() # VK_QUEUE_OPTICAL_FLOW_BIT_NV
-    DECODE         = auto() # VK_QUEUE_VIDEO_DECODE_BIT_KHR
-    ENCODE         = auto() # VK_QUEUE_VIDEO_ENCODE_BIT_KHR
-    ALL = TRANSFER | GRAPHICS | COMPUTE | PROTECTED | SPARSE_BINDING | OPTICAL_FLOW | DECODE | ENCODE
-
-class CommandScope(Enum):
-    NONE    = auto()
-    INSIDE  = auto()
-    OUTSIDE = auto()
-    BOTH    = auto()
-
-@dataclass
-class Command:
-    """<command>"""
-    name: str # ex) vkCmdDraw
-    alias: str # Because commands are interfaces into layers/drivers, we need all command alias
-    protect: (str | None) # ex) 'VK_ENABLE_BETA_EXTENSIONS'
-
-    extensions: list[Extension] # All extensions that enable the struct
-    version: (Version | None) # None if Version 1.0
-
-    returnType: str # ex) void, VkResult, etc
-
-    params: list[Param] # Each parameter of the command
-
-    # Only one will be True, the other is False
-    instance: bool
-    device: bool
-
-    tasks: list[str]        # ex) [ action, state, synchronization ]
-    queues: Queues          # zero == No Queues found
-    successCodes: list[str] # ex) [ VK_SUCCESS, VK_INCOMPLETE ]
-    errorCodes: list[str]   # ex) [ VK_ERROR_OUT_OF_HOST_MEMORY ]
-
-    # Shows support if command can be in a primary and/or secondary command buffer
-    primary: bool
-    secondary: bool
-
-    renderPass: CommandScope
-    videoCoding: CommandScope
-
-    implicitExternSyncParams: list[str]
-
-    # C prototype string - ex:
-    # VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
-    #   const VkInstanceCreateInfo* pCreateInfo,
-    #   const VkAllocationCallbacks* pAllocator,
-    #   VkInstance* pInstance);
-    cPrototype: str
-
-    # function pointer typedef  - ex:
-    # typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)
-    #   (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
-    cFunctionPointer: str
-
-@dataclass
-class Member:
-    """<member>"""
-    name: str # ex) sharingMode
-    type: str # ex) VkSharingMode
-
-    noAutoValidity: bool
-    limitType: (str | None) # ex) 'max', 'bitmask', 'bits', 'min,mul'
-
-    const: bool           # type contains 'const'
-    length:  (str | None) # the known length of pointer, will never be 'null-terminated'
-    nullTerminated: bool  # If a UTF-8 string, it will be null-terminated
-    pointer: bool         # type contains a pointer (include 'PFN' function pointers)
-    fixedSizeArray: list[str] # for VkTransformMatrixKHR:matrix this is [3, 4]
-
-    optional: bool
-    optionalPointer: bool # if type contains a pointer, is the pointer value optional
-
-    externSync: bool
-
-    # C string of member, example:
-    #   - const void* pNext
-    #   - VkFormat format
-    #   - VkStructureType sType
-    cDeclaration: str
-
-@dataclass
-class Struct:
-    """<type category="struct"> or <type category="union">"""
-    name: str # ex. VkBufferCreateInfo
-    extensions: list[Extension] # All extensions that enable the struct
-    version: (Version | None) # None if Version 1.0
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    members: list[Member]
-
-    union: bool # Unions are just a subset of a Structs
-    returnedOnly: bool
-
-    sType: (str | None) # ex) VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
-    allowDuplicate: bool # can have a pNext point to itself
-
-    # These use to be list['Struct'] but some circular loops occur and cause
-    # pydevd warnings and made debugging slow (30 seconds to index a Struct)
-    extends: list[str] # Struct names that this struct extends
-    extendedBy: list[str] # Struct names that can be extended by this struct
-
-@dataclass
-class EnumField:
-    """<enum> of type enum"""
-    name: str # ex) VK_DYNAMIC_STATE_SCISSOR
-    negative: bool # True if negative values are allowed (ex. VkResult)
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    # some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
-    extensions: list[Extension] # None if part of 1.0 core
-
-@dataclass
-class Enum:
-    """<enums> of type enum"""
-    name: str # ex) VkDynamicState
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    bitWidth: int # 32 or 64
-    returnedOnly: bool
-
-    fields: list[EnumField]
-
-    extensions: list[Extension] # None if part of 1.0 core
-    # Unique list of all extension that are involved in 'fields' (superset of 'extensions')
-    fieldExtensions: list[Extension]
-
-@dataclass
-class Flag:
-    """<enum> of type bitmask"""
-    name: str # ex) VK_ACCESS_2_SHADER_READ_BIT
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    value: int
-    multiBit: bool # if true, more than one bit is set (ex) VK_SHADER_STAGE_ALL_GRAPHICS)
-    zero: bool     # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE)
-
-    # some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
-    extensions: list[str] # None if part of 1.0 core
-
-@dataclass
-class Bitmask:
-    """<enums> of type bitmask"""
-    name: str     # ex) VkAccessFlagBits2
-    flagName: str # ex) VkAccessFlags2
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    bitWidth: int # 32 or 64
-    flags: list[Flag]
-
-    extensions: list[Extension] # None if part of 1.0 core
-    # Unique list of all extension that are involved in 'flag' (superset of 'extensions')
-    flagExtensions: list[Extension]
-
-@dataclass
-class FormatComponent:
-    """<format/component>"""
-    type: str # ex) R, G, B, A, D, S, etc
-    bits: str # will be an INT or 'compressed'
-    numericFormat: str # ex) UNORM, SINT, etc
-    planeIndex: (int | None) # None if no planeIndex in format
-
-@dataclass
-class FormatPlane:
-    """<format/plane>"""
-    index: int
-    widthDivisor: int
-    heightDivisor: int
-    compatible: str
-
-@dataclass
-class Format:
-    """<format>"""
-    name: str
-    className: str
-    blockSize: int
-    texelsPerBlock: int
-    blockExtent: list[str]
-    packed: (int | None) # None == not-packed
-    chroma: (str | None)
-    compressed: (str | None)
-    components: list[FormatComponent] # <format/component>
-    planes: list[FormatPlane]  # <format/plane>
-    spirvImageFormat: (str | None)
-
-@dataclass
-class SyncSupport:
-    """<syncsupport>"""
-    queues: Queues
-    stages: list[Flag] # VkPipelineStageFlagBits2
-    max: bool # If this supports max values
-
-@dataclass
-class SyncEquivalent:
-    """<syncequivalent>"""
-    stages: list[Flag] # VkPipelineStageFlagBits2
-    accesses: list[Flag] # VkAccessFlagBits2
-    max: bool # If this equivalent to everything
-
-@dataclass
-class SyncStage:
-    """<syncstage>"""
-    flag: Flag # VkPipelineStageFlagBits2
-    support: SyncSupport
-    equivalent: SyncEquivalent
-
-@dataclass
-class SyncAccess:
-    """<syncaccess>"""
-    flag: Flag # VkAccessFlagBits2
-    support: SyncSupport
-    equivalent: SyncEquivalent
-
-@dataclass
-class SyncPipelineStage:
-    """<syncpipelinestage>"""
-    order: (str | None)
-    before: (str | None)
-    after: (str | None)
-    value: str
-
-@dataclass
-class SyncPipeline:
-    """<syncpipeline>"""
-    name: str
-    depends: list[str]
-    stages: list[SyncPipelineStage]
-
-@dataclass
-class SpirvEnables:
-    """What is needed to enable the SPIR-V element"""
-    version: (str | None)
-    extension: (str | None)
-    struct: (str | None)
-    feature: (str | None)
-    requires: (str | None)
-    property: (str | None)
-    member: (str | None)
-    value: (str | None)
-
-@dataclass
-class Spirv:
-    """<spirvextension> and <spirvcapability>"""
-    name: str
-    # Only one will be True, the other is False
-    extension: bool
-    capability: bool
-    enable: list[SpirvEnables]
-
-# This is the global Vulkan Object that holds all the information from parsing the XML
-# This class is designed so all generator scripts can use this to obtain data
-@dataclass
-class VulkanObject():
-    headerVersion: int = 0 # value of VK_HEADER_VERSION
-
-    extensions: dict[str, Extension] = field(default_factory=dict, init=False)
-    versions:   dict[str, Version]   = field(default_factory=dict, init=False)
-
-    handles:  dict[str, Handle]      = field(default_factory=dict, init=False)
-    commands: dict[str, Command]     = field(default_factory=dict, init=False)
-    structs:  dict[str, Struct]      = field(default_factory=dict, init=False)
-    enums:    dict[str, Enum]        = field(default_factory=dict, init=False)
-    bitmasks: dict[str, Bitmask]     = field(default_factory=dict, init=False)
-    formats:  dict[str, Format]      = field(default_factory=dict, init=False)
-
-    syncStage:    list[SyncStage]    = field(default_factory=list, init=False)
-    syncAccess:   list[SyncAccess]   = field(default_factory=list, init=False)
-    syncPipeline: list[SyncPipeline] = field(default_factory=list, init=False)
-
-    spirv: list[Spirv]               = field(default_factory=list, init=False)
-
-    # ex) [ xlib : VK_USE_PLATFORM_XLIB_KHR ]
-    platforms: dict[str, str]        = field(default_factory=dict, init=False)
-    # list of all vendor Sufix names (KHR, EXT, etc. )
-    vendorTags: list[str]            = field(default_factory=list, init=False)
-    # ex) [ Queues.COMPUTE : VK_QUEUE_COMPUTE_BIT ]
-    queueBits: dict[IntFlag, str]    = field(default_factory=dict, init=False)

scripts/gn/gn.py

@@ -23,19 +23,19 @@ def BuildGn():
 
     print("Updating Repo Dependencies and GN Toolchain\n", flush=True)
     update_cmd = './scripts/gn/update_deps.sh'
-    subprocess.call(update_cmd)
+    subprocess.check_call(update_cmd)
 
     print("Checking Header Dependencies\n", flush=True)
     gn_check_cmd = 'gn gen --check out/Debug'.split(" ")
-    subprocess.call(gn_check_cmd)
+    subprocess.check_call(gn_check_cmd)
 
     print("Generating Ninja Files\n", flush=True)
     gn_gen_cmd = 'gn gen out/Debug'.split(" ")
-    subprocess.call(gn_gen_cmd)
+    subprocess.check_call(gn_gen_cmd)
 
     print("Running Ninja Build\n", flush=True)
     ninja_build_cmd = 'ninja -C out/Debug'.split(" ")
-    subprocess.call(ninja_build_cmd)
+    subprocess.check_call(ninja_build_cmd)
 
 #
 # Module Entrypoint

scripts/gn/stub.cpp

@@ -1,6 +1,6 @@
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2024 The Khronos Group Inc.
+// Copyright 2023-2024 Valve Corporation
+// Copyright 2023-2024 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 
@@ -9,6 +9,11 @@
 #include <vulkan/layer/vk_layer_settings.h>
 #include <vulkan/layer/vk_layer_settings.hpp>
 #include <vulkan/utility/vk_dispatch_table.h>
+#include <vulkan/utility/vk_concurrent_unordered_map.hpp>
 #include <vulkan/utility/vk_format_utils.h>
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/utility/vk_safe_struct_utils.hpp>
+#include <vulkan/utility/vk_small_containers.hpp>
+#include <vulkan/utility/vk_sparse_range_map.hpp>
 #include <vulkan/utility/vk_struct_helper.hpp>
 #include <vulkan/vk_enum_string_helper.h>

scripts/known_good.json

@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.275"
+            "commit": "v1.4.317"
         },
         {
             "name": "googletest",

scripts/update_deps.py

@@ -415,8 +415,15 @@ class GoodRepo(object):
         if VERBOSE:
             print('Checking out {n} in {d}'.format(n=self.name, d=self.repo_dir))
 
-        if self._args.do_clean_repo:
+        if os.path.exists(os.path.join(self.repo_dir, '.git')):
+            url_changed = command_output(['git', 'config', '--get', 'remote.origin.url'], self.repo_dir).strip() != self.url
+        else:
+            url_changed = False
+
+        if self._args.do_clean_repo or url_changed:
             if os.path.isdir(self.repo_dir):
+                if VERBOSE:
+                    print('Clearing directory {d}'.format(d=self.repo_dir))
                 shutil.rmtree(self.repo_dir, onerror = on_rm_error)
         if not os.path.exists(os.path.join(self.repo_dir, '.git')):
             self.Clone()
@@ -492,11 +499,12 @@ class GoodRepo(object):
         # Use the CMake -A option to select the platform architecture
         # without needing a Visual Studio generator.
         if platform.system() == 'Windows' and self._args.generator != "Ninja":
+            cmake_cmd.append('-A')
             if self._args.arch.lower() == '64' or self._args.arch == 'x64' or self._args.arch == 'win64':
-                cmake_cmd.append('-A')
                 cmake_cmd.append('x64')
+            elif self._args.arch == 'arm64':
+                cmake_cmd.append('arm64')
             else:
-                cmake_cmd.append('-A')
                 cmake_cmd.append('Win32')
 
         # Apply a generator, if one is specified.  This can be used to supply
@@ -614,7 +622,7 @@ def CreateHelper(args, repos, filename):
             if repo.api is not None and repo.api != args.api:
                 continue
             if install_names and repo.name in install_names and repo.on_build_platform:
-                helper_file.write('set({var} "{dir}" CACHE STRING "" FORCE)\n'
+                helper_file.write('set({var} "{dir}" CACHE STRING "")\n'
                                   .format(
                                       var=install_names[repo.name],
                                       dir=escape(repo.install_dir)))
@@ -677,7 +685,7 @@ def main():
     parser.add_argument(
         '--arch',
         dest='arch',
-        choices=['32', '64', 'x86', 'x64', 'win32', 'win64'],
+        choices=['32', '64', 'x86', 'x64', 'win32', 'win64', 'arm64'],
         type=str.lower,
         help="Set build files architecture (Visual Studio Generator Only)",
         default='64')

src/CMakeLists.txt

@@ -28,6 +28,7 @@ elseif(MSVC)
     target_compile_options(VulkanCompilerConfiguration INTERFACE
         /W4
         /we5038 # Enable warning about MIL ordering in constructors
+	/wd4324 # Disable warning about alignment padding
     )
 
     # Enforce stricter ISO C++
@@ -90,4 +91,7 @@ if (VUL_WERROR)
     endif()
 endif()
 
+option(VUL_MOCK_ANDROID "Enable building for Android on desktop for testing with MockICD setup")
+
 add_subdirectory(layer)
+add_subdirectory(vulkan)

src/layer/layer_settings_manager.cpp

@@ -33,8 +33,18 @@
 #include <algorithm>
 
 #if defined(__ANDROID__)
+/*
+ * Use the __system_property_read_callback API that appeared in
+ * Android API level 26. If not avaible use the old __system_property_get function.
+ */
+
+// Weak function declaration, used only when not declared in the Android headers
+void __system_property_read_callback(const prop_info *info,
+                                     void (*callback)(void *cookie, const char *name, const char *value, uint32_t serial),
+                                     void *cookie) __attribute__((weak));
 static std::string GetAndroidProperty(const char *name) {
     std::string output;
+#if __ANDROID_API__ >= 26
     const prop_info *pi = __system_property_find(name);
     if (pi) {
         __system_property_read_callback(
@@ -46,6 +56,13 @@ static std::string GetAndroidProperty(const char *name) {
             },
             reinterpret_cast<void *>(&output));
     }
+#else
+    char value_buf[PROP_VALUE_MAX] = "";
+    size_t len = static_cast<size_t>(__system_property_get(name, value_buf));
+    if (len > 0 && len < sizeof(value_buf)) {
+        output.assign(value_buf, len);
+    }
+#endif
     return output;
 }
 #endif

src/layer/vk_layer_settings.cpp

@@ -7,17 +7,19 @@
 // Author(s):
 // - Christophe Riccio <christophe@lunarg.com>
 #include "vulkan/layer/vk_layer_settings.h"
-#include "layer_settings_util.hpp"
 #include "layer_settings_manager.hpp"
+#include "layer_settings_util.hpp"
 
-#include <memory>
-#include <charconv>
-#include <cstdlib>
+#include <algorithm>
 #include <cassert>
-#include <cstring>
 #include <cctype>
-#include <cstring>
+#include <charconv>
 #include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <cstring>
+#include <memory>
+#include <system_error>
 #include <unordered_map>
 
 // This is used only for unit tests in test_layer_setting_file

src/layer/vk_layer_settings_helper.cpp

@@ -8,6 +8,8 @@
 // - Christophe Riccio <christophe@lunarg.com>
 #include "vulkan/layer/vk_layer_settings.hpp"
 
+#include <cstdlib>
+
 static std::string Merge(const std::vector<std::string> &strings) {
     std::string result;
 
@@ -21,139 +23,201 @@ static std::string Merge(const std::vector<std::string> &strings) {
     return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
     uint32_t value_count = 1;
     VkBool32 pValues;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
+    VkResult result =
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
     settingValue = pValues == VK_TRUE;
+    return result;
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
     uint32_t value_count = 0;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         std::vector<VkBool32> values(value_count);
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
         for (std::size_t i = 0, n = values.size(); i < n; ++i) {
             settingValues.push_back(values[i] == VK_TRUE);
         }
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<int32_t> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<int64_t> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<uint32_t> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<uint64_t> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
+    VkResult result =
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValues[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count,
+                                          &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<double> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
+    VkResult result =
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValues[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count,
+                                          &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) {
     std::vector<std::string> values;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, values);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, values);
     settingValue = Merge(values);
+    return result;
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<std::string> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<std::string> &settingValues) {
     uint32_t value_count = 0;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         std::vector<const char *> values(value_count);
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
         settingValues.assign(values.begin(), values.end());
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue) {
     uint32_t value_count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<VkuFrameset> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<VkuFrameset> &settingValues) {
     uint32_t value_count = 0;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count) / (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
 static uint32_t TokenToUint(const std::string &token) {
@@ -186,21 +250,29 @@ static void SetCustomStypeInfo(std::vector<const char *> raw_id_list, std::vecto
     }
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<VkuCustomSTypeInfo> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<VkuCustomSTypeInfo> &settingValues) {
     uint32_t value_count = 0;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         std::vector<const char *> values(value_count);
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
         SetCustomStypeInfo(values, settingValues);
     }
+    return result;
 }
 
 VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t settingsCount, const char **pSettings,
                                std::vector<const char *> &unknownSettings) {
     uint32_t unknown_setting_count = 0;
     VkResult result = vkuGetUnknownSettings(pFirstCreateInfo, settingsCount, pSettings, &unknown_setting_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
 
     if (unknown_setting_count > 0) {
         unknownSettings.resize(unknown_setting_count);

src/vulkan/CMakeLists.txt

@@ -0,0 +1,30 @@
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+set(CMAKE_FOLDER "${CMAKE_FOLDER}/VulkanSafeStruct")
+
+add_library(VulkanSafeStruct STATIC)
+add_library(Vulkan::SafeStruct ALIAS VulkanSafeStruct)
+
+target_sources(VulkanSafeStruct PRIVATE
+    vk_safe_struct_core.cpp
+    vk_safe_struct_ext.cpp
+    vk_safe_struct_khr.cpp
+    vk_safe_struct_utils.cpp
+    vk_safe_struct_vendor.cpp
+    vk_safe_struct_manual.cpp
+)
+
+target_link_Libraries(VulkanSafeStruct
+   PUBLIC
+      Vulkan::Headers
+      Vulkan::UtilityHeaders
+   PRIVATE
+      Vulkan::CompilerConfiguration
+)
+
+if(VUL_MOCK_ANDROID)
+	target_compile_definitions(VulkanSafeStruct PUBLIC VK_USE_PLATFORM_ANDROID_KHR VUL_MOCK_ANDROID)
+endif()

tests/CMakeLists.txt

@@ -1,6 +1,6 @@
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2024 The Khronos Group Inc.
+# Copyright 2023-2024 Valve Corporation
+# Copyright 2023-2024 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -16,6 +16,9 @@ target_include_directories(vul_tests PRIVATE
 )
 
 target_sources(vul_tests PRIVATE
+    safe_struct.cpp
+    small_containers.cpp
+    sparse_range_map.cpp
     struct_helper.cpp
     test_formats.cpp
     test_interface.cpp
@@ -35,6 +38,7 @@ target_link_libraries(vul_tests PRIVATE
     Vulkan::UtilityHeaders
     Vulkan::LayerSettings
     Vulkan::CompilerConfiguration
+    Vulkan::SafeStruct
 )
 
 # Test add_subdirectory suppport

tests/integration/vk_format_utils.c

@@ -1,6 +1,6 @@
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 #include <vulkan/utility/vk_format_utils.h>
@@ -8,7 +8,7 @@
 bool check_format_utils() {
     vkuGetPlaneIndex(VK_IMAGE_ASPECT_PLANE_1_BIT);
     vkuFormatHasGreen(VK_FORMAT_R8G8B8A8_UNORM);
-    vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT);
+    vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x4_SRGB_BLOCK);
     struct VKU_FORMAT_INFO f = vkuGetFormatInfo(VK_FORMAT_R8G8B8A8_SRGB);
     if (f.component_count != 4) {
         return false;

tests/integration/vk_format_utils_2.c

@@ -1,6 +1,6 @@
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 #include <vulkan/utility/vk_format_utils.h>
@@ -9,7 +9,7 @@
 bool check_format_utils_2() {
     vkuGetPlaneIndex(VK_IMAGE_ASPECT_PLANE_1_BIT);
     vkuFormatHasGreen(VK_FORMAT_R8G8B8A8_UNORM);
-    vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT);
+    vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x4_SRGB_BLOCK);
     struct VKU_FORMAT_INFO f = vkuGetFormatInfo(VK_FORMAT_R8G8B8A8_SRGB);
     if (f.component_count != 4) {
         return false;

tests/safe_struct.cpp

@@ -0,0 +1,240 @@
+// Copyright 2023 The Khronos Group Inc.
+// Copyright 2023 Valve Corporation
+// Copyright 2023 LunarG, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/utility/vk_struct_helper.hpp>
+#include <gtest/gtest.h>
+#include <array>
+
+TEST(safe_struct, basic) {
+    vku::safe_VkInstanceCreateInfo safe_info;
+    {
+        VkApplicationInfo app = vku::InitStructHelper();
+        app.pApplicationName = "test";
+        app.applicationVersion = 42;
+
+        VkDebugUtilsMessengerCreateInfoEXT debug_ci = vku::InitStructHelper();
+        debug_ci.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
+
+        VkInstanceCreateInfo info = vku::InitStructHelper();
+        info.pApplicationInfo = &app;
+        info.pNext = &debug_ci;
+
+        safe_info.initialize(&info);
+
+        memset(&info, 0x11, sizeof(info));
+        memset(&app, 0x22, sizeof(app));
+        memset(&debug_ci, 0x33, sizeof(debug_ci));
+    }
+    ASSERT_EQ(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, safe_info.sType);
+    ASSERT_EQ(0, strcmp("test", safe_info.pApplicationInfo->pApplicationName));
+    ASSERT_EQ(42u, safe_info.pApplicationInfo->applicationVersion);
+
+    auto debug_ci = vku::FindStructInPNextChain<VkDebugUtilsMessengerCreateInfoEXT>(safe_info.pNext);
+    ASSERT_NE(nullptr, debug_ci);
+    ASSERT_EQ(static_cast<VkDebugUtilsMessageSeverityFlagsEXT>(VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT),
+              debug_ci->messageSeverity);
+}
+
+TEST(safe_struct, safe_void_pointer_copies) {
+    // vku::safe_VkSpecializationInfo, constructor
+    {
+        std::vector<std::byte> data(20, std::byte{0b11110000});
+
+        VkSpecializationInfo info = {};
+        info.dataSize = uint32_t(data.size());
+        info.pData = data.data();
+
+        vku::safe_VkSpecializationInfo safe(&info);
+
+        ASSERT_TRUE(safe.pData != info.pData);
+        ASSERT_TRUE(safe.dataSize == info.dataSize);
+
+        data.clear();  // Invalidate any references, pointers, or iterators referring to contained elements.
+
+        auto copied_bytes = reinterpret_cast<const std::byte *>(safe.pData);
+        ASSERT_TRUE(copied_bytes[19] == std::byte{0b11110000});
+    }
+
+    // vku::safe_VkPipelineExecutableInternalRepresentationKHR, initialize
+    {
+        std::vector<std::byte> data(11, std::byte{0b01001001});
+
+        VkPipelineExecutableInternalRepresentationKHR info = {};
+        info.dataSize = uint32_t(data.size());
+        info.pData = data.data();
+
+        vku::safe_VkPipelineExecutableInternalRepresentationKHR safe;
+
+        safe.initialize(&info);
+
+        ASSERT_TRUE(safe.dataSize == info.dataSize);
+        ASSERT_TRUE(safe.pData != info.pData);
+
+        data.clear();  // Invalidate any references, pointers, or iterators referring to contained elements.
+
+        auto copied_bytes = reinterpret_cast<const std::byte *>(safe.pData);
+        ASSERT_TRUE(copied_bytes[10] == std::byte{0b01001001});
+    }
+}
+
+TEST(safe_struct, custom_safe_pnext_copy) {
+    // This tests an additional "copy_state" parameter in the SafePNextCopy function that allows "customizing" safe_* struct
+    // construction.. This is required for structs such as VkPipelineRenderingCreateInfo (which extend VkGraphicsPipelineCreateInfo)
+    // whose members must be partially ignored depending on the graphics sub-state present.
+
+    VkFormat format = VK_FORMAT_B8G8R8A8_UNORM;
+    VkPipelineRenderingCreateInfo pri = vku::InitStructHelper();
+    pri.colorAttachmentCount = 1;
+    pri.pColorAttachmentFormats = &format;
+
+    bool ignore_default_construction = true;
+    vku::PNextCopyState copy_state = {
+        [&ignore_default_construction](VkBaseOutStructure *safe_struct,
+                                       [[maybe_unused]] const VkBaseOutStructure *in_struct) -> bool {
+            if (ignore_default_construction) {
+                auto tmp = reinterpret_cast<vku::safe_VkPipelineRenderingCreateInfo *>(safe_struct);
+                tmp->colorAttachmentCount = 0;
+                tmp->pColorAttachmentFormats = nullptr;
+                return true;
+            }
+            return false;
+        },
+    };
+
+    {
+        VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&pri);
+        vku::safe_VkGraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, &copy_state);
+
+        auto safe_pri = reinterpret_cast<const vku::safe_VkPipelineRenderingCreateInfo *>(safe_gpci.pNext);
+        // Ensure original input struct was not modified
+        ASSERT_EQ(pri.colorAttachmentCount, 1u);
+        ASSERT_EQ(pri.pColorAttachmentFormats, &format);
+
+        // Ensure safe struct was modified
+        ASSERT_EQ(safe_pri->colorAttachmentCount, 0u);
+        ASSERT_EQ(safe_pri->pColorAttachmentFormats, nullptr);
+    }
+
+    // Ensure PNextCopyState::init is also applied when there is more than one element in the pNext chain
+    {
+        VkGraphicsPipelineLibraryCreateInfoEXT gpl_info = vku::InitStructHelper(&pri);
+        VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&gpl_info);
+
+        vku::safe_VkGraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, &copy_state);
+
+        auto safe_gpl_info = reinterpret_cast<const vku::safe_VkGraphicsPipelineLibraryCreateInfoEXT *>(safe_gpci.pNext);
+        auto safe_pri = reinterpret_cast<const vku::safe_VkPipelineRenderingCreateInfo *>(safe_gpl_info->pNext);
+        // Ensure original input struct was not modified
+        ASSERT_EQ(pri.colorAttachmentCount, 1u);
+        ASSERT_EQ(pri.pColorAttachmentFormats, &format);
+
+        // Ensure safe struct was modified
+        ASSERT_EQ(safe_pri->colorAttachmentCount, 0u);
+        ASSERT_EQ(safe_pri->pColorAttachmentFormats, nullptr);
+    }
+
+    // Check that signaling to use the default constructor works
+    {
+        pri.colorAttachmentCount = 1;
+        pri.pColorAttachmentFormats = &format;
+
+        ignore_default_construction = false;
+        VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&pri);
+        vku::safe_VkGraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, &copy_state);
+
+        auto safe_pri = reinterpret_cast<const vku::safe_VkPipelineRenderingCreateInfo *>(safe_gpci.pNext);
+        // Ensure original input struct was not modified
+        ASSERT_EQ(pri.colorAttachmentCount, 1u);
+        ASSERT_EQ(pri.pColorAttachmentFormats, &format);
+
+        // Ensure safe struct was modified
+        ASSERT_EQ(safe_pri->colorAttachmentCount, 1u);
+        ASSERT_EQ(*safe_pri->pColorAttachmentFormats, format);
+    }
+}
+
+TEST(safe_struct, extension_add_remove) {
+    std::array<const char *, 6> extensions{
+        "VK_KHR_maintenance1", "VK_KHR_maintenance2", "VK_KHR_maintenance3",
+        "VK_KHR_maintenance4", "VK_KHR_maintenance5", "VK_KHR_maintenance6",
+    };
+    VkDeviceCreateInfo ci = vku::InitStructHelper();
+    ci.ppEnabledExtensionNames = extensions.data();
+    ci.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
+
+    vku::safe_VkDeviceCreateInfo safe_ci(&ci);
+    ASSERT_EQ(3u, vku::FindExtension(safe_ci, "VK_KHR_maintenance4"));
+    ASSERT_EQ(safe_ci.enabledExtensionCount, vku::FindExtension(safe_ci, "VK_KHR_maintenance0"));
+
+    ASSERT_EQ(false, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0"));
+    ASSERT_EQ(true, vku::AddExtension(safe_ci, "VK_KHR_maintenance0"));
+
+    ASSERT_EQ(true, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0"));
+    for (const auto &ext : extensions) {
+        ASSERT_EQ(true, vku::RemoveExtension(safe_ci, ext));
+    }
+    ASSERT_EQ(false, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0"));
+
+    ASSERT_EQ(0u, safe_ci.enabledExtensionCount);
+    ASSERT_EQ(nullptr, safe_ci.ppEnabledExtensionNames);
+
+    for (const auto &ext : extensions) {
+        ASSERT_EQ(true, vku::AddExtension(safe_ci, ext));
+    }
+    ASSERT_EQ(extensions.size(), safe_ci.enabledExtensionCount);
+}
+
+TEST(safe_struct, pnext_add_remove) {
+    VkPhysicalDeviceRayTracingPipelineFeaturesKHR rtp = vku::InitStructHelper();
+    VkPhysicalDeviceRayQueryFeaturesKHR rtq = vku::InitStructHelper(&rtp);
+    VkPhysicalDeviceMeshShaderFeaturesEXT mesh = vku::InitStructHelper(&rtq);
+    VkPhysicalDeviceFeatures2 features = vku::InitStructHelper(&mesh);
+
+    vku::safe_VkPhysicalDeviceFeatures2 sf(&features);
+
+    // unlink the structs so they can be added one at a time.
+    rtp.pNext = nullptr;
+    rtq.pNext = nullptr;
+    mesh.pNext = nullptr;
+
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtq.sType));
+    ASSERT_EQ(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayQueryFeaturesKHR>(sf.pNext));
+    ASSERT_EQ(false, vku::RemoveFromPnext(sf, rtq.sType));
+
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtp.sType));
+    ASSERT_EQ(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(sf.pNext));
+
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, mesh.sType));
+    ASSERT_EQ(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(sf.pNext));
+
+    ASSERT_EQ(nullptr, sf.pNext);
+    ASSERT_EQ(true, vku::AddToPnext(sf, mesh));
+    ASSERT_EQ(false, vku::AddToPnext(sf, mesh));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(sf.pNext));
+
+    ASSERT_EQ(true, vku::AddToPnext(sf, rtq));
+    ASSERT_EQ(false, vku::AddToPnext(sf, rtq));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayQueryFeaturesKHR>(sf.pNext));
+
+    ASSERT_EQ(true, vku::AddToPnext(sf, rtp));
+    ASSERT_EQ(false, vku::AddToPnext(sf, rtp));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(sf.pNext));
+
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, mesh.sType));
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtp.sType));
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtq.sType));
+
+    // relink the structs so they can be added all at once
+    rtq.pNext = &rtp;
+    mesh.pNext = &rtq;
+
+    ASSERT_EQ(true, vku::AddToPnext(sf, mesh));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(sf.pNext));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(sf.pNext));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayQueryFeaturesKHR>(sf.pNext));
+}

tests/small_containers.cpp

@@ -0,0 +1,415 @@
+// Copyright 2024 The Khronos Group Inc.
+// Copyright 2024 Valve Corporation
+// Copyright 2024 LunarG, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+#include <array>
+#include <limits>
+#include <vector>
+#include <vulkan/utility/vk_small_containers.hpp>
+
+template <typename T, typename U>
+bool HaveSameElementsUpTo(const T& l1, const U& l2, size_t n) {
+    for (size_t i = 0; i < n; ++i) {
+        if (l1[static_cast<typename T::size_type>(i)] != l2[static_cast<typename U::size_type>(i)]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+template <typename T, typename U>
+bool HaveSameElements(const T& l1, const U& l2) {
+    return static_cast<size_t>(l1.size()) == static_cast<size_t>(l2.size()) && HaveSameElementsUpTo(l1, l2, l1.size());
+}
+
+TEST(small_vector, int_resize) {
+    // Resize int small vector, moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<int, 2, size_t> v1 = {1, 2, 3, 4};
+        v1.resize(v1.size());
+        std::array<int, 4> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v1, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<int, 2, size_t> v2 = {1, 2, 3, 4};
+        v2.resize(5);
+        std::array<int, 5> ref = {1, 2, 3, 4, 0};
+        ASSERT_TRUE(HaveSameElements(v2, ref));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<int, 2, size_t> v3 = {1, 2, 3, 4};
+        const auto v3_cap = v3.capacity();
+        v3.resize(3);
+        ASSERT_TRUE(v3.capacity() == v3_cap);  // Resize doesn't shrink capacity
+        v3.shrink_to_fit();
+        ASSERT_TRUE(v3.capacity() == v3.size());
+        std::array<int, 3> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v3, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<int, 2, size_t> v4 = {1, 2, 3, 4};
+        v4.resize(0);
+        ASSERT_TRUE(v4.capacity() == 4);  // Resize doesn't shrink capacity
+        v4.shrink_to_fit();
+        ASSERT_TRUE(v4.capacity() == 2);  // Small capacity is in the minimal
+        std::array<int, 0> ref = {};
+        ASSERT_TRUE(HaveSameElements(v4, ref));
+    }
+
+    {
+        // resize to size limit
+        vku::small::vector<int, 2, uint8_t> v5 = {1, 2, 3, 4};
+        v5.resize(std::numeric_limits<uint8_t>::max());
+        std::vector<int> vec = {1, 2, 3, 4};
+        vec.resize(std::numeric_limits<uint8_t>::max());
+        ASSERT_TRUE(HaveSameElements(v5, vec));
+    }
+
+    // Resize int small vector, not moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<int, 2, size_t> v6 = {1, 2, 3, 4};
+        v6.resize(v6.size());
+        std::array<int, 4> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v6, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<int, 2, size_t> v7 = {1, 2, 3, 4};
+        v7.resize(5);
+        std::array<int, 5> ref = {1, 2, 3, 4, 0};
+        ASSERT_TRUE(HaveSameElements(v7, ref));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<int, 2, size_t> v8 = {1, 2, 3, 4};
+        v8.resize(3);
+        std::array<int, 3> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v8, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<int, 2, size_t> v9 = {1, 2, 3, 4};
+        v9.resize(0);
+        std::array<int, 0> ref = {};
+        ASSERT_TRUE(HaveSameElements(v9, ref));
+    }
+
+    {
+        // resize to size limit
+        vku::small::vector<int, 2, uint8_t> v10 = {1, 2, 3, 4};
+        v10.resize(std::numeric_limits<uint8_t>::max());
+        std::vector<int> vec = {1, 2, 3, 4};
+        vec.resize(std::numeric_limits<uint8_t>::max());
+        ASSERT_TRUE(HaveSameElements(v10, vec));
+    }
+}
+
+struct NoDefaultCons {
+    NoDefaultCons(int x) : x(x) {}
+    int x;
+};
+
+bool operator!=(const NoDefaultCons& lhs, const NoDefaultCons& rhs) { return lhs.x != rhs.x; }
+
+TEST(small_vector, not_default_insertable) {
+    // Resize NoDefault small vector, moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<NoDefaultCons, 2, size_t> v1 = {1, 2, 3, 4};
+        v1.resize(v1.size());
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v1, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v2 = {1, 2, 3, 4};
+        v2.resize(5);
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElementsUpTo(v2, ref, ref.size()));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v3 = {1, 2, 3, 4};
+        const auto v3_cap = v3.capacity();
+        v3.resize(3);
+        ASSERT_TRUE(v3.capacity() == v3_cap);  // Resize doesn't shrink capacity
+        v3.shrink_to_fit();
+        ASSERT_TRUE(v3.capacity() == v3.size());
+
+        std::vector<NoDefaultCons> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v3, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<NoDefaultCons, 2, size_t> v4 = {1, 2, 3, 4};
+        v4.resize(0);
+        ASSERT_TRUE(v4.capacity() == 4);  // Resize doesn't shrink capacity
+        v4.shrink_to_fit();
+        ASSERT_TRUE(v4.capacity() == 2);  // Small capacity is in the minimal
+        std::vector<NoDefaultCons> ref = {};
+        ASSERT_TRUE(HaveSameElements(v4, ref));
+    }
+
+    // Resize NoDefault small vector, not moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<NoDefaultCons, 2, size_t> v6 = {1, 2, 3, 4};
+        v6.resize(v6.size());
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v6, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v7 = {1, 2, 3, 4};
+        v7.resize(5);
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElementsUpTo(v7, ref, ref.size()));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v8 = {1, 2, 3, 4};
+        v8.resize(3);
+        std::vector<NoDefaultCons> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v8, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<NoDefaultCons, 2, size_t> v9 = {1, 2, 3, 4};
+        v9.resize(0);
+        std::vector<NoDefaultCons> ref = {};
+        ASSERT_TRUE(HaveSameElements(v9, ref));
+    }
+}
+
+TEST(small_vector, not_default_insertable_default_value) {
+    // Resize NoDefault small vector, moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<NoDefaultCons, 2, size_t> v1 = {1, 2, 3, 4};
+        v1.resize(v1.size(), NoDefaultCons(0));
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v1, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v2 = {1, 2, 3, 4};
+        v2.resize(5, NoDefaultCons(0));
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4, 0};
+        ASSERT_TRUE(HaveSameElements(v2, ref));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v3 = {1, 2, 3, 4};
+        v3.resize(3, NoDefaultCons(0));
+        v3.shrink_to_fit();
+        ASSERT_TRUE(v3.capacity() == v3.size());
+        std::vector<NoDefaultCons> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v3, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<NoDefaultCons, 2, size_t> v4 = {1, 2, 3, 4};
+        v4.resize(0, NoDefaultCons(0));
+        ASSERT_TRUE(v4.capacity() == 4);  // Resize doesn't shrink capacity
+        v4.shrink_to_fit();
+        ASSERT_TRUE(v4.capacity() == 2);  // Small capacity is in the minimal
+        std::vector<NoDefaultCons> ref = {};
+        ASSERT_TRUE(HaveSameElements(v4, ref));
+    }
+
+    // Resize NoDefault small vector, not moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<NoDefaultCons, 2, size_t> v6 = {1, 2, 3, 4};
+        v6.resize(v6.size());
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v6, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v7 = {1, 2, 3, 4};
+        v7.resize(5, NoDefaultCons(0));
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4, 0};
+        ASSERT_TRUE(HaveSameElements(v7, ref));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v8 = {1, 2, 3, 4};
+        v8.resize(3, NoDefaultCons(0));
+        ASSERT_TRUE(v8.capacity() == 4);  // Resize doesn't shrink capacity
+        std::vector<NoDefaultCons> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v8, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<NoDefaultCons, 2, size_t> v9 = {1, 2, 3, 4};
+        v9.resize(0, NoDefaultCons(0));
+        ASSERT_TRUE(v9.capacity() == 4);  // Resize doesn't shrink capacity
+        std::vector<NoDefaultCons> ref = {};
+        ASSERT_TRUE(HaveSameElements(v9, ref));
+    }
+}
+TEST(small_vector, construct) {
+    using SmallVector = vku::small::vector<std::string, 5, size_t>;
+    const SmallVector ref_small = {"one", "two", "three", "four"};
+    SmallVector ref_large = {"one", "two", "three", "four", "five", "six"};
+
+    // Small construct and emplace vs. list (tests list contruction, really)
+    SmallVector v_small_emplace;
+    v_small_emplace.emplace_back("one");
+    v_small_emplace.emplace_back("two");
+    v_small_emplace.emplace_back("three");
+    v_small_emplace.emplace_back("four");
+    ASSERT_TRUE(HaveSameElements(ref_small, v_small_emplace));
+
+    // Copy construct from small_store
+    SmallVector v_small_copy(ref_small);
+    ASSERT_TRUE(HaveSameElements(ref_small, v_small_copy));
+
+    // Move construct from small_store
+    SmallVector v_small_move_src(ref_small);
+    SmallVector v_small_move_dst(std::move(v_small_move_src));
+    ASSERT_TRUE(HaveSameElements(ref_small, v_small_move_dst));
+
+    // Small construct and emplace vs. list (tests list contruction, really)
+    SmallVector v_large_emplace;
+    v_large_emplace.emplace_back("one");
+    v_large_emplace.emplace_back("two");
+    v_large_emplace.emplace_back("three");
+    v_large_emplace.emplace_back("four");
+    v_large_emplace.emplace_back("five");
+    v_large_emplace.emplace_back("six");
+    ASSERT_TRUE(HaveSameElements(ref_large, v_large_emplace));
+
+    // Copy construct from large_store
+    SmallVector v_large_copy(ref_large);
+    ASSERT_TRUE(HaveSameElements(ref_large, v_large_copy));
+
+    // Move construct from large_store
+    SmallVector v_large_move_src(ref_large);
+    SmallVector v_large_move_dst(std::move(v_large_move_src));
+    ASSERT_TRUE(HaveSameElements(ref_large, v_large_move_dst));
+}
+
+TEST(small_vector, assign) {
+    using SmallVector = vku::small::vector<std::string, 5, size_t>;
+    const SmallVector ref_xxs = {"one", "two"};
+    const SmallVector ref_xs = {"one", "two", "three"};
+    const SmallVector ref_small = {"one", "two", "three", "four"};
+
+    const SmallVector ref_large = {"one", "two", "three", "four", "five", "six"};
+    const SmallVector ref_xl = {"one", "two", "three", "four", "five", "six", "seven"};
+    const SmallVector ref_xxl = {"one", "two", "three", "four", "five", "six", "seven", "eight"};
+
+    SmallVector v_src(ref_large);
+    SmallVector v_dst(ref_small);
+
+    // Copy from large store to small store
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_large, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_large, v_dst));
+
+    // Quick small to large check to reset...
+    v_dst = ref_small;
+    ASSERT_TRUE(HaveSameElements(ref_small, v_dst));
+
+    // Copy from large store to small store
+    v_dst = std::move(v_src);
+    // Spec doesn't require src to be empty after move *assignment*
+    ASSERT_TRUE(HaveSameElements(ref_large, v_dst));
+
+    // Same store type copy/move
+
+    // Small
+    //
+    // Copy small to small reducing
+    v_src = ref_xs;
+    v_dst = ref_small;
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_xs, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_xs, v_dst));
+
+    // Move small to small reducing
+    v_src = ref_xs;
+    v_dst = ref_small;
+    v_dst = std::move(v_src);
+    // Small move operators don't empty source
+    ASSERT_TRUE(HaveSameElements(ref_xs, v_dst));
+
+    // Copy small to small increasing
+    v_src = ref_small;
+    v_dst = ref_xs;
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_small, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_small, v_dst));
+
+    // Move small to small increasing
+    v_src = ref_small;
+    v_dst = ref_xs;
+    v_dst = std::move(v_src);
+    // Small move operators don't empty source
+    ASSERT_TRUE(HaveSameElements(ref_small, v_dst));
+
+    // Large
+    //
+    // Copy large to large reducing
+    v_src = ref_large;
+    v_dst = ref_xl;
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_large, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_large, v_dst));
+
+    // Move large to large reducing
+    v_src = ref_large;
+    v_dst = ref_xl;
+    v_dst = std::move(v_src);
+    ASSERT_TRUE(v_src.empty());  // Since large moves move the large store, the source is empty, but not required by spec of vector
+    ASSERT_TRUE(HaveSameElements(ref_large, v_dst));
+
+    // Copy large to large increasing
+    v_src = ref_xxl;
+    v_dst = ref_xl;
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_xxl, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_xxl, v_dst));
+
+    // Move large to large increasing
+    v_src = ref_xxl;
+    v_dst = ref_xl;
+    v_dst = std::move(v_src);
+    ASSERT_TRUE(v_src.empty());
+    ASSERT_TRUE(HaveSameElements(ref_xxl, v_dst));
+}

tests/sparse_range_map.cpp

@@ -0,0 +1,43 @@
+// Copyright 2024 The Khronos Group Inc.
+// Copyright 2024 Valve Corporation
+// Copyright 2024 LunarG, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+#include <string>
+#include <utility>
+#include <vulkan/utility/vk_sparse_range_map.hpp>
+
+TEST(sparse_range_map, basic) {
+    vku::sparse::range_map<uint32_t, std::string> map;
+
+    map.insert(std::make_pair(vku::sparse::range<uint32_t>(0, 100), "first"));
+    map.insert(std::make_pair(vku::sparse::range<uint32_t>(500, 501), "second"));
+
+    auto iter = map.find(42);
+    ASSERT_NE(iter, map.end());
+    ASSERT_EQ(0u, iter->first.begin);
+    ASSERT_EQ(100u, iter->first.end);
+    ASSERT_EQ("first", iter->second);
+
+    iter = map.find(501);
+    ASSERT_EQ(iter, map.end());
+}
+
+TEST(sparse_range_map, small) {
+    vku::sparse::small_range_map<uint32_t, std::string> map;
+
+    map.insert(std::make_pair(vku::sparse::range<uint32_t>(0, 10), "first"));
+    map.insert(std::make_pair(vku::sparse::range<uint32_t>(50, 51), "second"));
+
+    auto iter = map.find(4);
+    ASSERT_NE(iter, map.end());
+    ASSERT_EQ(0u, iter->first.begin);
+    ASSERT_EQ(10u, iter->first.end);
+    ASSERT_EQ("first", iter->second);
+
+    iter = map.find(51);
+    ASSERT_EQ(iter, map.end());
+}

tests/struct_helper.cpp

@@ -27,11 +27,11 @@ TEST(struct_helper, structure_type_matches) {
         nullptr, static_cast<VkBufferCreateFlags>(VK_BUFFER_CREATE_SPARSE_BINDING_BIT), std::numeric_limits<uint64_t>::max(),
         static_cast<VkBufferUsageFlags>(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), VK_SHARING_MODE_EXCLUSIVE, 0U, nullptr);
     ASSERT_EQ(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, buffer_create_info.sType);
-    ASSERT_EQ(VK_BUFFER_CREATE_SPARSE_BINDING_BIT, buffer_create_info.flags);
+    ASSERT_EQ(static_cast<VkBufferCreateFlags>(VK_BUFFER_CREATE_SPARSE_BINDING_BIT), buffer_create_info.flags);
     ASSERT_EQ(std::numeric_limits<uint64_t>::max(), buffer_create_info.size);
-    ASSERT_EQ(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, buffer_create_info.usage);
+    ASSERT_EQ(static_cast<VkBufferUsageFlags>(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), buffer_create_info.usage);
     ASSERT_EQ(VK_SHARING_MODE_EXCLUSIVE, buffer_create_info.sharingMode);
-    ASSERT_EQ(0, buffer_create_info.queueFamilyIndexCount);
+    ASSERT_EQ(0u, buffer_create_info.queueFamilyIndexCount);
     ASSERT_EQ(nullptr, buffer_create_info.pQueueFamilyIndices);
 }
 

tests/test_formats.cpp

@@ -1,6 +1,6 @@
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 //
@@ -259,22 +259,22 @@ TEST(format_utils, vkuFormatIsStencilOnly) {
 TEST(format_utils, vkuFormatDepthSize) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (std::string::npos != format_str.find("_D16")) {
-            EXPECT_EQ(vkuFormatDepthSize(format), 16);
+            EXPECT_EQ(vkuFormatDepthSize(format), 16u);
         } else if (std::string::npos != format_str.find("_D24")) {
-            EXPECT_EQ(vkuFormatDepthSize(format), 24);
+            EXPECT_EQ(vkuFormatDepthSize(format), 24u);
         } else if (std::string::npos != format_str.find("_D32")) {
-            EXPECT_EQ(vkuFormatDepthSize(format), 32);
+            EXPECT_EQ(vkuFormatDepthSize(format), 32u);
         } else {
-            EXPECT_EQ(vkuFormatDepthSize(format), 0);
+            EXPECT_EQ(vkuFormatDepthSize(format), 0u);
         }
     }
 }
 TEST(format_utils, vkuFormatStencilSize) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (std::string::npos != format_str.find("_S8")) {
-            EXPECT_EQ(vkuFormatStencilSize(format), 8);
+            EXPECT_EQ(vkuFormatStencilSize(format), 8u);
         } else {
-            EXPECT_EQ(vkuFormatStencilSize(format), 0);
+            EXPECT_EQ(vkuFormatStencilSize(format), 0u);
         }
     }
 }
@@ -350,11 +350,11 @@ TEST(format_utils, vkuFormatIsSinglePlane_422) {
 TEST(format_utils, vkuFormatPlaneCount) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (std::string::npos != format_str.find("2PLANE")) {
-            EXPECT_EQ(vkuFormatPlaneCount(format), 2);
+            EXPECT_EQ(vkuFormatPlaneCount(format), 2u);
         } else if (std::string::npos != format_str.find("3PLANE")) {
-            EXPECT_EQ(vkuFormatPlaneCount(format), 3);
+            EXPECT_EQ(vkuFormatPlaneCount(format), 3u);
         } else {
-            EXPECT_EQ(vkuFormatPlaneCount(format), 1);
+            EXPECT_EQ(vkuFormatPlaneCount(format), 1u);
         }
     }
 }
@@ -385,31 +385,51 @@ TEST(format_utils, vkuFindMultiplaneCompatibleFormat) {
 TEST(format_utils, vkuFindMultiplaneExtentDivisors) {
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_0_BIT).width,
-        1);
+        1u);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_1_BIT).width,
-        2);
+        2u);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_2_BIT).width,
-        2);
+        2u);
 
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_0_BIT).height,
-        1);
+        1u);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_1_BIT).height,
-        2);
+        2u);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_2_BIT).height,
-        2);
+        2u);
 
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT).width, 1);
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT).width, 2);
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT).width, 1);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT).width, 1u);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT).width, 2u);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT).width, 1u);
 
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT).height, 1);
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT).height, 1);
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT).height, 1);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT).height, 1u);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT).height, 1u);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT).height, 1u);
+}
+
+TEST(format_utils, vkuFormatIsDepthStencilWithColorSizeCompatible) {
+    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
+                                                                VK_FORMAT_D16_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT));
+    EXPECT_FALSE(
+        vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_D16_UNORM, VK_FORMAT_R16_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT));
+    EXPECT_FALSE(
+        vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT));
+    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT));
+
+    EXPECT_TRUE(
+        vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_SFLOAT, VK_FORMAT_D16_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_D16_UNORM_S8_UINT,
+                                                               VK_IMAGE_ASPECT_STENCIL_BIT));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_D16_UNORM_S8_UINT,
+                                                               VK_IMAGE_ASPECT_DEPTH_BIT));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_D16_UNORM_S8_UINT,
+                                                               VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT));
 }
 
 TEST(format_utils, vkuFormatComponentCount) {
@@ -430,24 +450,24 @@ TEST(format_utils, vkuFormatTexelBlockExtent) {
     for (auto format : formats) {
         auto extent = vkuFormatTexelBlockExtent(format);
         if (vkuFormatIsCompressed(format)) {
-            EXPECT_GT(extent.width, 1);
-            EXPECT_GT(extent.height, 1);
-            EXPECT_EQ(extent.depth, 1);
+            EXPECT_GT(extent.width, 1u);
+            EXPECT_GT(extent.height, 1u);
+            EXPECT_EQ(extent.depth, 1u);
         } else if (format == VK_FORMAT_UNDEFINED) {
-            EXPECT_EQ(extent.width, 0);
-            EXPECT_EQ(extent.height, 0);
-            EXPECT_EQ(extent.depth, 0);
+            EXPECT_EQ(extent.width, 0u);
+            EXPECT_EQ(extent.height, 0u);
+            EXPECT_EQ(extent.depth, 0u);
             continue;
         } else {
-            EXPECT_EQ(extent.width, 1);
-            EXPECT_EQ(extent.height, 1);
-            EXPECT_EQ(extent.depth, 1);
+            EXPECT_EQ(extent.width, 1u);
+            EXPECT_EQ(extent.height, 1u);
+            EXPECT_EQ(extent.depth, 1u);
         }
     }
     auto extent = vkuFormatTexelBlockExtent(static_cast<VkFormat>(10001));
-    EXPECT_EQ(extent.width, 0);
-    EXPECT_EQ(extent.height, 0);
-    EXPECT_EQ(extent.depth, 0);
+    EXPECT_EQ(extent.width, 0u);
+    EXPECT_EQ(extent.height, 0u);
+    EXPECT_EQ(extent.depth, 0u);
 }
 TEST(format_utils, vkuFormatCompatibilityClass) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
@@ -503,67 +523,29 @@ TEST(format_utils, vkuFormatCompatibilityClass) {
         }
     }
 }
-TEST(format_utils, vkuFormatElementIsTexel) {
-    constexpr auto formats = magic_enum::enum_values<VkFormat>();
-    for (auto format : formats) {
-        if (!(vkuFormatIsPacked(format) || vkuFormatIsCompressed(format) || vkuFormatIsSinglePlane_422(format) ||
-              vkuFormatIsMultiplane(format))) {
-            EXPECT_TRUE(vkuFormatElementIsTexel(format));
-        } else {
-            EXPECT_FALSE(vkuFormatElementIsTexel(format));
-        }
-    }
+
+TEST(format_utils, vkuFormatTexelsPerBlock) {
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_R64G64_SFLOAT), 1u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_BC6H_UFLOAT_BLOCK), 16u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_ASTC_5x4_SRGB_BLOCK), 20u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_ASTC_5x5_SRGB_BLOCK), 25u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_ASTC_12x12_SRGB_BLOCK), 144u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM), 1u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_D32_SFLOAT), 1u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_D32_SFLOAT_S8_UINT), 1u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_S8_UINT), 1u);
 }
-TEST(format_utils, vkuFormatElementSizeWithAspect) {
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_NONE), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_NONE), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_0_BIT), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_1_BIT), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_2_BIT), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_NONE), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT), 2);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT), 2);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT), 2);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_NONE), 4);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 4);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 5);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 4);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 1);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-}
-TEST(format_utils, vkuFormatTexelSizeWithAspect) {
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_NONE), 16);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_NONE), 16. / 20.);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_NONE), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT), 2);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT), 2);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT), 2);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_NONE), 4);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 4);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 5);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 4);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 1);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
+
+TEST(format_utils, vkuFormatTexelBlockSize) {
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_R64G64_SFLOAT), 16u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x4_SRGB_BLOCK), 16u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x5_SRGB_BLOCK), 16u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM), 6u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_D32_SFLOAT), 4u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_D32_SFLOAT_S8_UINT), 5u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_S8_UINT), 1u);
 }
+
 TEST(format_utils, vkuFormatIs64bit) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (std::string::npos != format_str.find("R64")) {
@@ -649,12 +631,12 @@ struct magic_enum::customize::enum_range<VkImageAspectFlagBits> {
 TEST(format_utils, vkuGetPlaneIndex) {
     for (auto [aspect_flag, aspect_flag_str] : magic_enum::enum_entries<VkImageAspectFlagBits>()) {
         if (std::string::npos != aspect_flag_str.find("_ASPECT_PLANE_0")) {
-            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 0);
+            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 0u);
         } else if (std::string::npos != aspect_flag_str.find("_ASPECT_PLANE_1")) {
-            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 1);
+            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 1u);
 
         } else if (std::string::npos != aspect_flag_str.find("_ASPECT_PLANE_2")) {
-            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 2);
+            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 2u);
         } else {
             EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), VKU_FORMAT_INVALID_INDEX);
         }

tests/test_interface.cpp

@@ -44,11 +44,13 @@ TEST(test_vk_dispatch_table, cpp_interface) {
 
     vkuInitInstanceDispatchTable(instance, &instance_dispatch_table, local_vkGetInstanceProcAddr);
 
-    ASSERT_EQ(instance_dispatch_table.GetInstanceProcAddr, local_vkGetInstanceProcAddr);
+    ASSERT_EQ(reinterpret_cast<PFN_vkVoidFunction>(instance_dispatch_table.GetInstanceProcAddr),
+              reinterpret_cast<PFN_vkVoidFunction>(local_vkGetInstanceProcAddr));
 
     VkDevice device{};
 
     vkuInitDeviceDispatchTable(device, &device_dispatch_table, local_vkGetDeviceProcAddr);
 
-    ASSERT_EQ(device_dispatch_table.GetDeviceProcAddr, local_vkGetDeviceProcAddr);
+    ASSERT_EQ(reinterpret_cast<PFN_vkVoidFunction>(device_dispatch_table.GetDeviceProcAddr),
+              reinterpret_cast<PFN_vkVoidFunction>(local_vkGetDeviceProcAddr));
 }

tests/test_setting_api.cpp

@@ -203,25 +203,25 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Bool) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
 
-    value_count = 1;
+    value_count = 1u;
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
-    value_count = 2;
+    value_count = 2u;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -244,7 +244,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
 
@@ -254,7 +254,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -262,7 +262,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -285,7 +285,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
 
@@ -295,7 +295,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -303,7 +303,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -326,7 +326,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
 
@@ -334,17 +334,17 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint32) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(0u, values[1]);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -367,7 +367,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
 
@@ -377,7 +377,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -385,7 +385,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -408,7 +408,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Float) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<float> values(static_cast<uint32_t>(value_count));
 
@@ -417,7 +417,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Float) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -425,7 +425,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Float) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -448,7 +448,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Double) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<double> values(static_cast<uint32_t>(value_count));
 
@@ -457,7 +457,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Double) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -465,7 +465,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Double) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -490,7 +490,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Frameset) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
 
@@ -498,22 +498,22 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Frameset) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -535,7 +535,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> values(static_cast<uint32_t>(value_count));
 
@@ -545,7 +545,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ(nullptr, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -553,7 +553,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }

tests/test_setting_cast.cpp

@@ -32,7 +32,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Bool) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
 
@@ -41,7 +41,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Bool) {
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("true", string_values[0]);
     EXPECT_STREQ("false", string_values[1]);
 
@@ -70,14 +70,14 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("-82", string_values[1]);
 
@@ -106,14 +106,14 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("-82", string_values[1]);
 
@@ -140,16 +140,16 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint32) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("82", string_values[1]);
 
@@ -176,7 +176,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint64) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
 
@@ -185,7 +185,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint64) {
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("82", string_values[1]);
 
@@ -212,7 +212,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Float) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
 
@@ -221,7 +221,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Float) {
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr);
     EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr);
 
@@ -250,14 +250,14 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Double) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr);
     EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr);
 
@@ -286,18 +286,18 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Frameset) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
-    EXPECT_EQ(6, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
+    EXPECT_EQ(6u, value_count);
 
     value_count = 0;
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, nullptr);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
@@ -305,7 +305,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Frameset) {
     result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count,
                                                &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76-100-10", string_values[0]);
     EXPECT_STREQ("1-100-1", string_values[1]);
 
@@ -333,7 +333,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }

tests/test_setting_cpp.cpp

@@ -122,7 +122,7 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Uint32) {
     std::uint32_t pValues;
     vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
-    EXPECT_EQ(76, pValues);
+    EXPECT_EQ(76u, pValues);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -146,9 +146,9 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Uint32) {
     std::vector<std::uint32_t> values;
     vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, values.size());
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, values.size());
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -421,9 +421,9 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Frameset) {
     VkuFrameset pValues;
     vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
-    EXPECT_EQ(76, pValues.first);
-    EXPECT_EQ(100, pValues.count);
-    EXPECT_EQ(10, pValues.step);
+    EXPECT_EQ(76u, pValues.first);
+    EXPECT_EQ(100u, pValues.count);
+    EXPECT_EQ(10u, pValues.step);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -447,12 +447,12 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Frameset) {
     std::vector<VkuFrameset> values;
     vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
     EXPECT_EQ(2, values.size());
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
@@ -476,10 +476,10 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_VkuCustomSTypeInfo) {
 
     std::vector<VkuCustomSTypeInfo> values;
     vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
-    EXPECT_EQ(0x76, values[0].first);
-    EXPECT_EQ(0x82, values[0].second);
-    EXPECT_EQ(76, values[1].first);
-    EXPECT_EQ(82, values[1].second);
+    EXPECT_EQ(0x76u, values[0].first);
+    EXPECT_EQ(0x82u, values[0].second);
+    EXPECT_EQ(76u, values[1].first);
+    EXPECT_EQ(82u, values[1].second);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }

tests/test_setting_env.cpp

@@ -33,7 +33,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNone) {
     VkResult result_count_a =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting_a", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_a, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_a);
-    EXPECT_EQ(2, value_count_a);
+    EXPECT_EQ(2u, value_count_a);
 
     std::vector<VkBool32> values_a(static_cast<std::size_t>(value_count_a));
     VkResult result_complete_a =
@@ -41,7 +41,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNone) {
     EXPECT_EQ(VK_SUCCESS, result_complete_a);
     EXPECT_EQ(VK_TRUE, values_a[0]);
     EXPECT_EQ(VK_FALSE, values_a[1]);
-    EXPECT_EQ(2, value_count_a);
+    EXPECT_EQ(2u, value_count_a);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -58,7 +58,7 @@ TEST(test_layer_setting_env, EnvVar_TrimVendor) {
     VkResult result_count_b =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting_b", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_b, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_b);
-    EXPECT_EQ(2, value_count_b);
+    EXPECT_EQ(2u, value_count_b);
 
     std::vector<VkBool32> values_b(static_cast<std::size_t>(value_count_b));
     VkResult result_complete_b =
@@ -66,7 +66,7 @@ TEST(test_layer_setting_env, EnvVar_TrimVendor) {
     EXPECT_EQ(VK_SUCCESS, result_complete_b);
     EXPECT_EQ(VK_TRUE, values_b[0]);
     EXPECT_EQ(VK_FALSE, values_b[1]);
-    EXPECT_EQ(2, value_count_b);
+    EXPECT_EQ(2u, value_count_b);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -83,7 +83,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNamespace) {
     VkResult result_count_c =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_c);
-    EXPECT_EQ(2, value_count_c);
+    EXPECT_EQ(2u, value_count_c);
 
     std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c));
     VkResult result_complete_c =
@@ -91,7 +91,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNamespace) {
     EXPECT_EQ(VK_SUCCESS, result_complete_c);
     EXPECT_EQ(VK_TRUE, values_c[0]);
     EXPECT_EQ(VK_FALSE, values_c[1]);
-    EXPECT_EQ(2, value_count_c);
+    EXPECT_EQ(2u, value_count_c);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -110,7 +110,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNamespace_OveriddenPrefix) {
     VkResult result_count_c =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_c);
-    EXPECT_EQ(2, value_count_c);
+    EXPECT_EQ(2u, value_count_c);
 
     std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c));
     VkResult result_complete_c =
@@ -118,7 +118,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNamespace_OveriddenPrefix) {
     EXPECT_EQ(VK_SUCCESS, result_complete_c);
     EXPECT_EQ(VK_TRUE, values_c[0]);
     EXPECT_EQ(VK_FALSE, values_c[1]);
-    EXPECT_EQ(2, value_count_c);
+    EXPECT_EQ(2u, value_count_c);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -135,7 +135,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Bool) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
 
@@ -145,7 +145,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Bool) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -153,7 +153,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Bool) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -170,7 +170,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
 
@@ -180,7 +180,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -188,7 +188,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -205,7 +205,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
 
@@ -215,7 +215,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -223,7 +223,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -240,7 +240,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
 
@@ -248,17 +248,17 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint32) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(0u, values[1]);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -275,7 +275,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
 
@@ -285,7 +285,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -293,7 +293,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -310,7 +310,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Float) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<float> values(static_cast<uint32_t>(value_count));
 
@@ -319,7 +319,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Float) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -327,7 +327,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Float) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -344,7 +344,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Double) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<double> values(static_cast<uint32_t>(value_count));
 
@@ -353,7 +353,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Double) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -361,7 +361,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Double) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -378,7 +378,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Frameset) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
 
@@ -386,22 +386,22 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Frameset) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -418,7 +418,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> values(static_cast<uint32_t>(value_count));
 
@@ -428,7 +428,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ(nullptr, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -436,7 +436,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 

tests/test_setting_file.cpp

@@ -25,7 +25,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Bool) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
 
@@ -35,7 +35,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Bool) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -43,7 +43,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Bool) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -60,7 +60,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
 
@@ -70,7 +70,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -78,7 +78,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -95,7 +95,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
 
@@ -105,7 +105,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -113,7 +113,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -130,7 +130,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
 
@@ -138,17 +138,17 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint32) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(0u, values[1]);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -165,7 +165,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
 
@@ -175,7 +175,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -183,7 +183,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -200,7 +200,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Float) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<float> values(static_cast<uint32_t>(value_count));
 
@@ -209,7 +209,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Float) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -217,7 +217,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Float) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -234,7 +234,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Double) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<double> values(static_cast<uint32_t>(value_count));
 
@@ -243,7 +243,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Double) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -251,7 +251,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Double) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -268,7 +268,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Frameset) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
 
@@ -276,22 +276,22 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Frameset) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -308,7 +308,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char *> values(static_cast<uint32_t>(value_count));
 
@@ -318,7 +318,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ(nullptr, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -326,7 +326,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }

tests/test_setting_util.cpp

@@ -328,19 +328,19 @@ TEST(test_layer_settings_util, is_float) {
 }
 
 TEST(test_layer_settings_util, ToUint32) {
-    EXPECT_EQ(24, vl::ToUint32("24"));
-    EXPECT_EQ(3000300000, vl::ToUint32("3000300000"));
-    EXPECT_EQ(15, vl::ToUint32("0xF"));
-    EXPECT_EQ(15, vl::ToUint32("0XF"));
-    EXPECT_EQ(4294967295, vl::ToUint32("0xFFFFFFFF"));
+    EXPECT_EQ(24u, vl::ToUint32("24"));
+    EXPECT_EQ(3000300000u, vl::ToUint32("3000300000"));
+    EXPECT_EQ(15u, vl::ToUint32("0xF"));
+    EXPECT_EQ(15u, vl::ToUint32("0XF"));
+    EXPECT_EQ(4294967295u, vl::ToUint32("0xFFFFFFFF"));
 }
 
 TEST(test_layer_settings_util, ToUint64) {
-    EXPECT_EQ(24, vl::ToUint64("24"));
-    EXPECT_EQ(3000300000, vl::ToUint64("3000300000"));
-    EXPECT_EQ(15, vl::ToUint64("0xF"));
-    EXPECT_EQ(15, vl::ToUint64("0XF"));
-    EXPECT_EQ(4294967295, vl::ToUint64("0xFFFFFFFF"));
+    EXPECT_EQ(24ull, vl::ToUint64("24"));
+    EXPECT_EQ(3000300000ull, vl::ToUint64("3000300000"));
+    EXPECT_EQ(15ull, vl::ToUint64("0xF"));
+    EXPECT_EQ(15ull, vl::ToUint64("0XF"));
+    EXPECT_EQ(4294967295ull, vl::ToUint64("0xFFFFFFFF"));
     EXPECT_EQ(4294967296ull, vl::ToUint64("0x100000000"));
 }
 
@@ -408,173 +408,173 @@ TEST(test_layer_settings_util, to_framesets) {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(0, framesets[0].first);
-        EXPECT_EQ(1, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(0u, framesets[0].first);
+        EXPECT_EQ(1u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("76");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(76, framesets[0].first);
-        EXPECT_EQ(1, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(76u, framesets[0].first);
+        EXPECT_EQ(1u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(0, framesets[0].first);
-        EXPECT_EQ(2, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(0u, framesets[0].first);
+        EXPECT_EQ(2u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6,7");
         EXPECT_EQ(3, framesets.size());
 
-        EXPECT_EQ(0, framesets[0].first);
-        EXPECT_EQ(2, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(0u, framesets[0].first);
+        EXPECT_EQ(2u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(6, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(6u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
 
-        EXPECT_EQ(7, framesets[2].first);
-        EXPECT_EQ(1, framesets[2].count);
-        EXPECT_EQ(1, framesets[2].step);
+        EXPECT_EQ(7u, framesets[2].first);
+        EXPECT_EQ(1u, framesets[2].count);
+        EXPECT_EQ(1u, framesets[2].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6-7");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(0, framesets[0].first);
-        EXPECT_EQ(2, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(0u, framesets[0].first);
+        EXPECT_EQ(2u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(6, framesets[1].first);
-        EXPECT_EQ(7, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(6u, framesets[1].first);
+        EXPECT_EQ(7u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-2,60,70");
         EXPECT_EQ(3, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(2, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(2u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(60, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(60u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
 
-        EXPECT_EQ(70, framesets[2].first);
-        EXPECT_EQ(1, framesets[2].count);
-        EXPECT_EQ(1, framesets[2].step);
+        EXPECT_EQ(70u, framesets[2].first);
+        EXPECT_EQ(1u, framesets[2].count);
+        EXPECT_EQ(1u, framesets[2].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("10-20,60,70");
         EXPECT_EQ(3, framesets.size());
 
-        EXPECT_EQ(10, framesets[0].first);
-        EXPECT_EQ(20, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(10u, framesets[0].first);
+        EXPECT_EQ(20u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(60, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(60u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
 
-        EXPECT_EQ(70, framesets[2].first);
-        EXPECT_EQ(1, framesets[2].count);
-        EXPECT_EQ(1, framesets[2].step);
+        EXPECT_EQ(70u, framesets[2].first);
+        EXPECT_EQ(1u, framesets[2].count);
+        EXPECT_EQ(1u, framesets[2].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(2, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(2u, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,0");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(2, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(2u, framesets[0].step);
 
-        EXPECT_EQ(0, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(0u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-5");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(2, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(2u, framesets[0].step);
 
-        EXPECT_EQ(10, framesets[1].first);
-        EXPECT_EQ(20, framesets[1].count);
-        EXPECT_EQ(5, framesets[1].step);
+        EXPECT_EQ(10u, framesets[1].first);
+        EXPECT_EQ(20u, framesets[1].count);
+        EXPECT_EQ(5u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8,10-20-5");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(10, framesets[1].first);
-        EXPECT_EQ(20, framesets[1].count);
-        EXPECT_EQ(5, framesets[1].step);
+        EXPECT_EQ(10u, framesets[1].first);
+        EXPECT_EQ(20u, framesets[1].count);
+        EXPECT_EQ(5u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-1");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(2, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(2u, framesets[0].step);
 
-        EXPECT_EQ(10, framesets[1].first);
-        EXPECT_EQ(20, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(10u, framesets[1].first);
+        EXPECT_EQ(20u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1,2,3,4");
         EXPECT_EQ(4, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(1, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(1u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(2, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(2u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
 
-        EXPECT_EQ(3, framesets[2].first);
-        EXPECT_EQ(1, framesets[2].count);
-        EXPECT_EQ(1, framesets[2].step);
+        EXPECT_EQ(3u, framesets[2].first);
+        EXPECT_EQ(1u, framesets[2].count);
+        EXPECT_EQ(1u, framesets[2].step);
 
-        EXPECT_EQ(4, framesets[3].first);
-        EXPECT_EQ(1, framesets[3].count);
-        EXPECT_EQ(1, framesets[3].step);
+        EXPECT_EQ(4u, framesets[3].first);
+        EXPECT_EQ(1u, framesets[3].count);
+        EXPECT_EQ(1u, framesets[3].step);
     }
 }
 
@@ -664,13 +664,13 @@ TEST(test_layer_settings_util, vkuGetUnknownSettings_SingleCreateInfo) {
 
     uint32_t unknown_settings_count = 0;
     vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, nullptr);
-    EXPECT_EQ(2, unknown_settings_count);
+    EXPECT_EQ(2u, unknown_settings_count);
 
     std::vector<const char*> unknown_settings(unknown_settings_count);
 
     unknown_settings_count = 1;
     vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
-    EXPECT_EQ(1, unknown_settings_count);
+    EXPECT_EQ(1u, unknown_settings_count);
     EXPECT_STREQ("bool_value", unknown_settings[0]);
 
     unknown_settings_count = 2;
@@ -777,13 +777,13 @@ TEST(test_layer_settings_util, vlGetUnknownSettings_MultipleCreateInfo) {
 
     uint32_t unknown_settings_count = 0;
     vkuGetUnknownSettings(&create_infoA, setting_name_count, setting_names, &unknown_settings_count, nullptr);
-    EXPECT_EQ(2, unknown_settings_count);
+    EXPECT_EQ(2u, unknown_settings_count);
 
     std::vector<const char*> unknown_settings(unknown_settings_count);
 
     unknown_settings_count = 1;
     vkuGetUnknownSettings(&create_infoA, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
-    EXPECT_EQ(1, unknown_settings_count);
+    EXPECT_EQ(1u, unknown_settings_count);
     EXPECT_STREQ("bool_value", unknown_settings[0]);
 
     unknown_settings_count = 2;