Merge branch 'main' into add-layer-schema

.github/workflows/ci.yml

@@ -1,6 +1,6 @@
-# Copyright 2023-2024 The Khronos Group Inc.
-# Copyright 2023-2024 Valve Corporation
-# Copyright 2023-2024 LunarG, Inc.
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -14,39 +14,27 @@ 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-22.04, ubuntu-24.04, windows-latest, macos-latest ]
+        os: [ ubuntu-20.04, ubuntu-22.04, windows-latest, macos-latest ]
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Python 3.8
-        if: matrix.os != 'macos-latest'
-        uses: actions/setup-python@v5
+      - 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-22.04'
+        if: matrix.os == 'ubuntu-20.04'
         uses: lukka/get-cmake@latest
         with:
-          cmakeVersion: 3.22.1
+          cmakeVersion: 3.17.2
       - 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
@@ -58,11 +46,9 @@ jobs:
       - run: cmake -S. -B build -D VUL_WERROR=ON -D CMAKE_BUILD_TYPE=Debug -D UPDATE_DEPS=ON
       - run: cmake --build build
       - run: cmake --install build --prefix build/install
-
+ 
   android:
-    # Use chromium as a test build, so don't run this job unless something simple works first
-    needs: chromium
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
     strategy:
       matrix:
         abi: [ armeabi-v7a, arm64-v8a ]
@@ -92,12 +78,11 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: REUSE Compliance Check
-      uses: fsfe/reuse-action@v5
+      uses: fsfe/reuse-action@v2
 
   # Test to ensure we don't accidentally break the Chromium build.
   chromium:
-    needs: generate_source
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
@@ -109,7 +94,7 @@ jobs:
         run: python scripts/gn/gn.py
 
   generate_source:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.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.15.0
+      uses: jidicula/clang-format-action@v4.11.0
       with:
         clang-format-version: '14'
         check-path: ${{ matrix.path }}

.gitignore

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

.reuse/dep5

@@ -6,3 +6,7 @@ Source: https://github.com/KhronosGroup/Vulkan-Utility-Libraries
 Files: scripts/known_good.json scripts/update_deps.py scripts/CMakeLists.txt
 Copyright: 2023 The Khronos Group Inc.
 License: Apache-2.0
+
+Files: schema/layers_schema.json
+Copyright: 2020-2023 The Khronos Group Inc.
+License: Apache-2.0

BUILD.gn

@@ -6,7 +6,6 @@ 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") {
@@ -15,11 +14,8 @@ 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",
@@ -29,11 +25,5 @@ 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.22.1
+1. CMake >= 3.17.2
 2. C++ >= c++17 compiler. See platform-specific sections below for supported compiler versions.
 3. Python >= 3.8
 

CMakeLists.txt

@@ -3,10 +3,12 @@
 # Copyright 2023 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
-cmake_minimum_required(VERSION 3.22.1)
+cmake_minimum_required(VERSION 3.17.2)
 
 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)
@@ -25,51 +27,30 @@ 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 (PROJECT_IS_TOP_LEVEL)
+if (VUL_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/vulkan/"
+        DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/${API_TYPE}/"
         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 VulkanSafeStruct VulkanCompilerConfiguration
+        TARGETS VulkanLayerSettings VulkanUtilityHeaders 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}};
 
@@ -368,14 +368,4 @@ $ export VK_VALIDATION_DEBUG_ACTION=VK_DBG_LAYER_ACTION_LOG_MSG
 $ 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,20 +1,13 @@
-# Copyright 2023-2024 The Khronos Group Inc.
-# Copyright 2023-2024 Valve Corporation
-# Copyright 2023-2024 LunarG, Inc.
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 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
-)
-
-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
+	vulkan/layer/vk_layer_settings.h
+	vulkan/layer/vk_layer_settings.hpp
 )
 
 set(CMAKE_FOLDER "${CMAKE_FOLDER}/VulkanUtilityHeaders")
@@ -24,18 +17,15 @@ 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/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
-    )
+	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
+	)
 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,58 +10,52 @@
 #pragma once
 
 #include "vk_layer_settings.h"
-
-#include <string>
-#include <utility>
 #include <vector>
+#include <string>
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue);
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues);
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue);
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<int32_t> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues);
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue);
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<int64_t> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues);
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue);
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<uint32_t> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues);
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue);
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<uint64_t> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues);
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue);
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues);
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue);
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues);
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue);
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<std::string> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                              std::vector<std::string> &settingValues);
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue);
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<VkuFrameset> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                              std::vector<VkuFrameset> &settingValues);
 
 // Required by vk_safe_struct
 typedef std::pair<uint32_t, uint32_t> VkuCustomSTypeInfo;
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<VkuCustomSTypeInfo> &settingValues);
+void 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

@@ -1,203 +0,0 @@
-/* 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,10 +160,7 @@ 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
@@ -354,25 +351,6 @@ 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;
@@ -443,8 +421,6 @@ 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;
@@ -467,6 +443,8 @@ 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;
@@ -481,13 +459,6 @@ 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;
@@ -512,7 +483,6 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyCuFunctionNVX DestroyCuFunctionNVX;
     PFN_vkCmdCuLaunchKernelNVX CmdCuLaunchKernelNVX;
     PFN_vkGetImageViewHandleNVX GetImageViewHandleNVX;
-    PFN_vkGetImageViewHandle64NVX GetImageViewHandle64NVX;
     PFN_vkGetImageViewAddressNVX GetImageViewAddressNVX;
     PFN_vkCmdDrawIndirectCountAMD CmdDrawIndirectCountAMD;
     PFN_vkCmdDrawIndexedIndirectCountAMD CmdDrawIndexedIndirectCountAMD;
@@ -578,7 +548,6 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCompileDeferredNV CompileDeferredNV;
     PFN_vkGetMemoryHostPointerPropertiesEXT GetMemoryHostPointerPropertiesEXT;
     PFN_vkCmdWriteBufferMarkerAMD CmdWriteBufferMarkerAMD;
-    PFN_vkCmdWriteBufferMarker2AMD CmdWriteBufferMarker2AMD;
     PFN_vkGetCalibratedTimestampsEXT GetCalibratedTimestampsEXT;
     PFN_vkCmdDrawMeshTasksNV CmdDrawMeshTasksNV;
     PFN_vkCmdDrawMeshTasksIndirectNV CmdDrawMeshTasksIndirectNV;
@@ -587,7 +556,6 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdSetExclusiveScissorNV CmdSetExclusiveScissorNV;
     PFN_vkCmdSetCheckpointNV CmdSetCheckpointNV;
     PFN_vkGetQueueCheckpointDataNV GetQueueCheckpointDataNV;
-    PFN_vkGetQueueCheckpointData2NV GetQueueCheckpointData2NV;
     PFN_vkInitializePerformanceApiINTEL InitializePerformanceApiINTEL;
     PFN_vkUninitializePerformanceApiINTEL UninitializePerformanceApiINTEL;
     PFN_vkCmdSetPerformanceMarkerINTEL CmdSetPerformanceMarkerINTEL;
@@ -635,17 +603,12 @@ 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
@@ -713,6 +676,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetPipelineIndirectMemoryRequirementsNV GetPipelineIndirectMemoryRequirementsNV;
     PFN_vkCmdUpdatePipelineIndirectBufferNV CmdUpdatePipelineIndirectBufferNV;
     PFN_vkGetPipelineIndirectDeviceAddressNV GetPipelineIndirectDeviceAddressNV;
+    PFN_vkCmdSetTessellationDomainOriginEXT CmdSetTessellationDomainOriginEXT;
     PFN_vkCmdSetDepthClampEnableEXT CmdSetDepthClampEnableEXT;
     PFN_vkCmdSetPolygonModeEXT CmdSetPolygonModeEXT;
     PFN_vkCmdSetRasterizationSamplesEXT CmdSetRasterizationSamplesEXT;
@@ -723,7 +687,6 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdSetColorBlendEnableEXT CmdSetColorBlendEnableEXT;
     PFN_vkCmdSetColorBlendEquationEXT CmdSetColorBlendEquationEXT;
     PFN_vkCmdSetColorWriteMaskEXT CmdSetColorWriteMaskEXT;
-    PFN_vkCmdSetTessellationDomainOriginEXT CmdSetTessellationDomainOriginEXT;
     PFN_vkCmdSetRasterizationStreamEXT CmdSetRasterizationStreamEXT;
     PFN_vkCmdSetConservativeRasterizationModeEXT CmdSetConservativeRasterizationModeEXT;
     PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT CmdSetExtraPrimitiveOverestimationSizeEXT;
@@ -744,32 +707,18 @@ 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;
@@ -779,28 +728,6 @@ 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;
@@ -1017,25 +944,6 @@ 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");
@@ -1106,8 +1014,6 @@ 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");
@@ -1130,6 +1036,8 @@ 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");
@@ -1144,13 +1052,6 @@ 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");
@@ -1175,7 +1076,6 @@ 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");
@@ -1241,7 +1141,6 @@ 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");
@@ -1250,7 +1149,6 @@ 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");
@@ -1298,17 +1196,12 @@ 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
@@ -1376,6 +1269,7 @@ 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");
@@ -1386,7 +1280,6 @@ 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");
@@ -1407,32 +1300,18 @@ 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");
@@ -1442,28 +1321,6 @@ 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");
@@ -1630,9 +1487,6 @@ 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

@@ -1,126 +0,0 @@
-/***************************************************************************
- *
- * 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

@@ -1,713 +0,0 @@
-/* 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,56 +232,6 @@ 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; }
@@ -362,6 +312,10 @@ 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; }
@@ -380,6 +334,7 @@ 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
@@ -404,7 +359,6 @@ 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; }
@@ -416,13 +370,14 @@ 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; }
@@ -431,6 +386,8 @@ 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; }
@@ -445,89 +402,40 @@ 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<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<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<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<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<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<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; }
@@ -540,7 +448,6 @@ 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; }
@@ -563,6 +470,9 @@ 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; }
@@ -574,7 +484,6 @@ 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; }
@@ -611,7 +520,6 @@ 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; }
@@ -661,6 +569,7 @@ 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; }
@@ -668,8 +577,6 @@ 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; }
@@ -689,7 +596,6 @@ 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; }
@@ -717,11 +623,22 @@ 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<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<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<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; }
@@ -751,6 +668,8 @@ 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; }
@@ -759,19 +678,11 @@ 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; }
@@ -838,7 +749,6 @@ 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; }
@@ -913,15 +823,16 @@ 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<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<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<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; }
@@ -929,9 +840,6 @@ 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; }
@@ -948,30 +856,6 @@ 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; }
@@ -984,14 +868,12 @@ 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; }
@@ -1002,14 +884,8 @@ 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; }
@@ -1046,76 +922,6 @@ 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; }
@@ -1130,6 +936,7 @@ 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; }
@@ -1205,12 +1012,13 @@ 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; }
@@ -1246,7 +1054,6 @@ 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; }
@@ -1255,29 +1062,17 @@ 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; }
 
-# 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
+#endif // VK_USE_64_BIT_PTR_DEFINES == 1
 } // namespace vku
 
 // NOLINTEND// clang-format on

scripts/common_ci.py

@@ -1,54 +0,0 @@
-#!/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,16 +8,10 @@
 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
@@ -25,24 +19,17 @@ 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)
-    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 reg import Registry
 
-    from base_generator import BaseGeneratorOptions
+    from generators.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 base_generator import (SetTargetApiName, SetMergedApiNames)
+    from generators.base_generator import (SetTargetApiName, SetMergedApiNames)
     SetTargetApiName(api)
 
     # Build up a list of all generators and custom options
@@ -50,63 +37,31 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
         'vk_dispatch_table.h' : {
            'generator' : DispatchTableOutputGenerator,
            'genCombined': True,
-           'directory' : f'include/vulkan/utility',
+           'directory' : f'include/{api}/utility',
         },
         'vk_enum_string_helper.h' : {
             'generator' : EnumStringHelperOutputGenerator,
             'genCombined': True,
-            'directory' : f'include/vulkan',
+            'directory' : f'include/{api}',
         },
         'vk_format_utils.h' : {
             'generator' : FormatUtilsOutputGenerator,
             'genCombined': True,
-            'directory' : f'include/vulkan/utility',
+            'directory' : f'include/{api}/utility',
         },
         'vk_struct_helper.hpp' : {
             'generator' : StructHelperOutputGenerator,
             'genCombined': True,
-            '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',
+            'directory' : f'include/{api}/utility',
         },
     }
 
-    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
+    if (targetFilter and targetFilter not in generators.keys()):
+        print(f'ERROR: No generator options for unknown target: {targetFilter}', file=sys.stderr)
+        sys.exit(1)
 
     # Filter if --target is passed in
-    targets = [x for x in generators.keys() if not targetFilter or x in targetFilter]
+    targets = [x for x in generators.keys() if not targetFilter or x == targetFilter]
 
     for index, target in enumerate(targets, start=1):
         print(f'[{index}|{len(targets)}] Generating {target}')
@@ -147,9 +102,6 @@ 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')
@@ -159,16 +111,10 @@ 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', nargs='+', help='only generate file name passed in')
+    group.add_argument('--target', 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

@@ -0,0 +1,728 @@
+#!/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 base_generator import BaseGenerator
+from generators.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.add_guard(command.protect))
+            out.extend(guard_helper.addGuard(command.protect))
             out.append(f'    PFN_{command.name} {command.name[2:]};\n')
-        out.extend(guard_helper.add_guard(None))
+        out.extend(guard_helper.addGuard(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.add_guard(command.protect))
+            out.extend(guard_helper.addGuard(command.protect))
             out.append(f'    PFN_{command.name} {command.name[2:]};\n')
-        out.extend(guard_helper.add_guard(None))
+        out.extend(guard_helper.addGuard(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.add_guard(command.protect))
+            out.extend(guard_helper.addGuard(command.protect))
             out.append(f'    table->{command.name[2:]} = (PFN_{command.name})gdpa(device, "{command.name}");\n')
-        out.extend(guard_helper.add_guard(None))
+        out.extend(guard_helper.addGuard(None))
         out.append('}\n')
 
         out.append('''
@@ -89,9 +89,9 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance
                 'vkEnumerateInstanceVersion',
                 'vkGetInstanceProcAddr',
         ]]:
-            out.extend(guard_helper.add_guard(command.protect))
+            out.extend(guard_helper.addGuard(command.protect))
             out.append(f'    table->{command.name[2:]} = (PFN_{command.name})gipa(instance, "{command.name}");\n')
-        out.extend(guard_helper.add_guard(None))
+        out.extend(guard_helper.addGuard(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-2025 The Khronos Group Inc.
-# Copyright 2023-2025 Valve Corporation
-# Copyright 2023-2025 LunarG, Inc.
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-from base_generator import BaseGenerator
+from generators.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-2025 The Khronos Group Inc.
-// Copyright 2023-2025 Valve Corporation
-// Copyright 2023-2025 LunarG, Inc.
+// Copyright 2023 The Khronos Group Inc.
+// Copyright 2023 Valve Corporation
+// Copyright 2023 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.add_guard(enum.protect))
+            out.extend(guard_helper.addGuard(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.add_guard(field.protect))
+                out.extend(enum_field_guard_helper.addGuard(field.protect))
                 out.append(f'        case {field.name}:\n')
                 out.append(f'            return "{field.name}";\n')
-            out.extend(enum_field_guard_helper.add_guard(None))
+            out.extend(enum_field_guard_helper.addGuard(None))
             out.append('        default:\n')
             out.append(f'            return "Unhandled {enum.name}";\n')
             out.append('    }\n')
             out.append('}\n')
-        out.extend(guard_helper.add_guard(None))
+        out.extend(guard_helper.addGuard(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.add_guard(bitmask.protect))
+            out.extend(guard_helper.addGuard(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.add_guard(flag.protect))
+                    out.extend(bitmask_field_guard_helper.addGuard(flag.protect))
                     out.append(f'        case {flag.name}:\n')
                     out.append(f'            return "{flag.name}";\n')
-                out.extend(bitmask_field_guard_helper.add_guard(None))
+                out.extend(bitmask_field_guard_helper.addGuard(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.add_guard(flag.protect))
+                    out.extend(bitmask_field_guard_helper.addGuard(flag.protect))
                     out.append(f'    if (input_value == {flag.name}) return "{flag.name}";\n')
-                out.extend(bitmask_field_guard_helper.add_guard(None))
+                out.extend(bitmask_field_guard_helper.addGuard(None))
                 out.append(f'    return "Unhandled {bitmask.name}";\n')
             out.append('}\n')
 
@@ -110,23 +110,6 @@ static inline std::string string_{bitmask.flagName}({bitmask.flagName} input_val
     return ret;
 }}\n''')
             out.append('#endif // __cplusplus\n')
-        out.extend(guard_helper.add_guard(None))
+        out.extend(guard_helper.addGuard(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,15 +1,14 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023-2025 The Khronos Group Inc.
-# Copyright 2023-2025 Valve Corporation
-# Copyright 2023-2025 LunarG, Inc.
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-from collections import namedtuple
-from vulkan_object import (Format)
-from base_generator import BaseGenerator
+from generators.vulkan_object import (Format)
+from generators.base_generator import BaseGenerator
 
 # Make C name friendly class name
 def getClassName(className: str) -> str:
@@ -26,13 +25,7 @@ def formatHasEqualBitsize(format: Format, bitsize: str) -> bool:
 
 # True if all components are same numericFormat
 def formatHasNumericFormat(format: Format, numericFormat: str) -> bool:
-    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)
+    return all(x.numericFormat == numericFormat for x in format.components)
 
 class FormatUtilsOutputGenerator(BaseGenerator):
     def __init__(self):
@@ -78,9 +71,9 @@ class FormatUtilsOutputGenerator(BaseGenerator):
         out = []
         out.append(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See {os.path.basename(__file__)} for modifications
-// Copyright 2023-2025 The Khronos Group Inc.
-// Copyright 2023-2025 Valve Corporation
-// Copyright 2023-2025 LunarG, Inc.
+// Copyright 2023 The Khronos Group Inc.
+// Copyright 2023 Valve Corporation
+// Copyright 2023 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 ''')
@@ -202,8 +195,6 @@ 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
@@ -214,10 +205,6 @@ 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);
 
@@ -227,14 +214,24 @@ 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);
 
-// 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 true if a VkFormat is 'normal', with one texel per format element
+inline bool vkuFormatElementIsTexel(VkFormat format);
 
-// 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);
+// 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);
 
 ''')
         for bits in ['8', '16', '32', '64']:
@@ -281,7 +278,7 @@ enum VKU_FORMAT_COMPONENT_TYPE {
 };
 
 // Compressed formats don't have a defined component size
-#define VKU_FORMAT_COMPRESSED_COMPONENT 0xFFFFFFFF
+const uint32_t VKU_FORMAT_COMPRESSED_COMPONENT = 0xFFFFFFFF;
 
 struct VKU_FORMAT_COMPONENT_INFO {
     enum VKU_FORMAT_COMPONENT_TYPE type;
@@ -291,64 +288,34 @@ struct VKU_FORMAT_COMPONENT_INFO {
 // Generic information for all formats
 struct VKU_FORMAT_INFO {
     enum VKU_FORMAT_COMPATIBILITY_CLASS compatibility;
-    uint32_t texel_block_size;  // bytes
-    uint32_t texels_per_block;
+    uint32_t block_size;  // bytes
+    uint32_t texel_per_block;
     VkExtent3D block_extent;
     uint32_t component_count;
     struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
 };
 ''')
-        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():
+        out.append('inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {\n')
+        out.append('    switch (format) {\n')
+        for f in self.vk.formats.values():
             className = getClassName(f.className)
             blockExtent = ', '.join(f.blockExtent) if f.blockExtent is not None else '1, 1, 1'
-            out.extend(f'    {{ VKU_FORMAT_COMPATIBILITY_CLASS_{className}, {f.blockSize}, {f.texelsPerBlock}, {{{blockExtent}}}, {len(f.components)}, {{')
+            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)}, {{')
             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('};\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];
-    }
+            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;
+        }
+    };
 }
 
 struct VKU_FORMAT_PER_PLANE_COMPATIBILITY {
@@ -588,42 +555,52 @@ 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 uint32_t vkuFormatTexelsPerBlock(VkFormat format) { return vkuGetFormatInfo(format).texels_per_block; }
+inline bool vkuFormatElementIsTexel(VkFormat format) {
+    if (vkuFormatIsPacked(format) || vkuFormatIsCompressed(format) || vkuFormatIsSinglePlane_422(format) || vkuFormatIsMultiplane(format)) {
+        return false;
+    } else {
+        return true;
+    }
+}
 
-inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
+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;
+}
 
 ''')
         # Could loop the components, but faster to just list these

scripts/generators/generator_utils.py

@@ -1,148 +1,25 @@
 #!/usr/bin/python3 -i
 #
-# Copyright (c) 2023-2024 Valve Corporation
-# Copyright (c) 2023-2024 LunarG, Inc.
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
+# Copyright 2023 RasterGrid Kft.
 #
 # 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 add_guard(None) when done to add a trailing #endif if needed
+    Note - be sure to call addGuard(None) when done to add a trailing #endif if needed
     """
     def __init__(self):
-        self.current_guard = None
+        self.currentGuard = None
 
-    def add_guard(self, guard, extra_newline = False):
+    def addGuard(self, guard):
         out = []
-        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
+        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
         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

@@ -1,813 +0,0 @@
-#!/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 base_generator import BaseGenerator
+from generators.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.add_guard(struct.protect))
+            out.extend(guard_helper.addGuard(struct.protect))
             out.append(f'template <> inline VkStructureType GetSType<{struct.name}>() {{ return {struct.sType}; }}\n')
-        out.extend(guard_helper.add_guard(None))
+        out.extend(guard_helper.addGuard(None))
         out.append('''
 // Find an entry of the given type in the const pNext chain
 // returns nullptr if the entry is not found
@@ -123,24 +123,20 @@ 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.add_guard(handle.protect))
+            out.extend(guard_helper.addGuard(handle.protect))
             out.append(f'template<> inline VkObjectType GetObjectType<{handle.name}>() {{ return {handle.type}; }}\n')
-        out.extend(guard_helper.add_guard(None))
+        out.extend(guard_helper.addGuard(None))
         out.append('''
-# 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
+#endif // VK_USE_64_BIT_PTR_DEFINES == 1
 } // namespace vku
 \n''')
 

scripts/generators/vulkan_object.py

@@ -0,0 +1,377 @@
+#!/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.check_call(update_cmd)
+    subprocess.call(update_cmd)
 
     print("Checking Header Dependencies\n", flush=True)
     gn_check_cmd = 'gn gen --check out/Debug'.split(" ")
-    subprocess.check_call(gn_check_cmd)
+    subprocess.call(gn_check_cmd)
 
     print("Generating Ninja Files\n", flush=True)
     gn_gen_cmd = 'gn gen out/Debug'.split(" ")
-    subprocess.check_call(gn_gen_cmd)
+    subprocess.call(gn_gen_cmd)
 
     print("Running Ninja Build\n", flush=True)
     ninja_build_cmd = 'ninja -C out/Debug'.split(" ")
-    subprocess.check_call(ninja_build_cmd)
+    subprocess.call(ninja_build_cmd)
 
 #
 # Module Entrypoint

scripts/gn/stub.cpp

@@ -1,6 +1,6 @@
-// Copyright 2023-2024 The Khronos Group Inc.
-// Copyright 2023-2024 Valve Corporation
-// Copyright 2023-2024 LunarG, Inc.
+// Copyright 2023 The Khronos Group Inc.
+// Copyright 2023 Valve Corporation
+// Copyright 2023 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 
@@ -9,11 +9,6 @@
 #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.4.317"
+            "commit": "v1.3.275"
         },
         {
             "name": "googletest",
@@ -46,4 +46,4 @@
         "googletest": "GOOGLETEST_INSTALL_DIR",
         "magic_enum": "MAGIC_ENUM_INSTALL_DIR"
     }
-}
+}

scripts/update_deps.py

@@ -415,15 +415,8 @@ class GoodRepo(object):
         if VERBOSE:
             print('Checking out {n} in {d}'.format(n=self.name, d=self.repo_dir))
 
-        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 self._args.do_clean_repo:
             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()
@@ -499,12 +492,11 @@ 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
@@ -622,7 +614,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 "")\n'
+                helper_file.write('set({var} "{dir}" CACHE STRING "" FORCE)\n'
                                   .format(
                                       var=install_names[repo.name],
                                       dir=escape(repo.install_dir)))
@@ -685,7 +677,7 @@ def main():
     parser.add_argument(
         '--arch',
         dest='arch',
-        choices=['32', '64', 'x86', 'x64', 'win32', 'win64', 'arm64'],
+        choices=['32', '64', 'x86', 'x64', 'win32', 'win64'],
         type=str.lower,
         help="Set build files architecture (Visual Studio Generator Only)",
         default='64')

src/CMakeLists.txt

@@ -28,7 +28,6 @@ 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++
@@ -91,7 +90,4 @@ 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,18 +33,8 @@
 #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(
@@ -56,13 +46,6 @@ 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,19 +7,17 @@
 // Author(s):
 // - Christophe Riccio <christophe@lunarg.com>
 #include "vulkan/layer/vk_layer_settings.h"
-#include "layer_settings_manager.hpp"
 #include "layer_settings_util.hpp"
+#include "layer_settings_manager.hpp"
 
-#include <algorithm>
-#include <cassert>
-#include <cctype>
-#include <charconv>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-#include <cstring>
 #include <memory>
-#include <system_error>
+#include <charconv>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cctype>
+#include <cstring>
+#include <cstdint>
 #include <unordered_map>
 
 // This is used only for unit tests in test_layer_setting_file

src/layer/vk_layer_settings_helper.cpp

@@ -8,8 +8,6 @@
 // - 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;
 
@@ -23,201 +21,139 @@ static std::string Merge(const std::vector<std::string> &strings) {
     return result;
 }
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
     uint32_t value_count = 1;
     VkBool32 pValues;
-    VkResult result =
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
     settingValue = pValues == VK_TRUE;
-    return result;
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
     uint32_t value_count = 0;
-    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     if (value_count > 0) {
         std::vector<VkBool32> values(value_count);
-        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        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;
 }
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) {
     uint32_t value_count = 1;
-    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue);
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<int32_t> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues) {
     uint32_t value_count = 1;
-    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        result =
-            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]);
     }
-    return result;
 }
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) {
     uint32_t value_count = 1;
-    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue);
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<int64_t> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues) {
     uint32_t value_count = 1;
-    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        result =
-            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]);
     }
-    return result;
 }
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) {
     uint32_t value_count = 1;
-    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<uint32_t> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues) {
     uint32_t value_count = 1;
-    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        result =
-            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
     }
-    return result;
 }
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) {
     uint32_t value_count = 1;
-    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue);
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<uint64_t> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues) {
     uint32_t value_count = 1;
-    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        result =
-            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]);
     }
-    return result;
 }
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
     uint32_t value_count = 1;
-    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue);
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
     uint32_t value_count = 1;
-    VkResult result =
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count,
-                                          &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValues[0]);
     }
-    return result;
 }
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
     uint32_t value_count = 1;
-    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue);
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<double> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) {
     uint32_t value_count = 1;
-    VkResult result =
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count,
-                                          &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValues[0]);
     }
-    return result;
 }
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) {
     std::vector<std::string> values;
-    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, values);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, values);
     settingValue = Merge(values);
-    return result;
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<std::string> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                              std::vector<std::string> &settingValues) {
     uint32_t value_count = 0;
-    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     if (value_count > 0) {
         std::vector<const char *> values(value_count);
-        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
         settingValues.assign(values.begin(), values.end());
     }
-    return result;
 }
 
-VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue) {
     uint32_t value_count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
-    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<VkuFrameset> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                              std::vector<VkuFrameset> &settingValues) {
     uint32_t value_count = 0;
-    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count) / (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
-        result =
-            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
     }
-    return result;
 }
 
 static uint32_t TokenToUint(const std::string &token) {
@@ -250,29 +186,21 @@ static void SetCustomStypeInfo(std::vector<const char *> raw_id_list, std::vecto
     }
 }
 
-VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                                  std::vector<VkuCustomSTypeInfo> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                              std::vector<VkuCustomSTypeInfo> &settingValues) {
     uint32_t value_count = 0;
-    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
-    if (result != VK_SUCCESS) {
-        return result;
-    }
-
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     if (value_count > 0) {
         std::vector<const char *> values(value_count);
-        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        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

@@ -1,30 +0,0 @@
-# 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-2024 The Khronos Group Inc.
-# Copyright 2023-2024 Valve Corporation
-# Copyright 2023-2024 LunarG, Inc.
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -16,9 +16,6 @@ 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
@@ -38,7 +35,6 @@ 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-2025 The Khronos Group Inc.
-// Copyright 2023-2025 Valve Corporation
-// Copyright 2023-2025 LunarG, Inc.
+// Copyright 2023 The Khronos Group Inc.
+// Copyright 2023 Valve Corporation
+// Copyright 2023 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);
-    vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x4_SRGB_BLOCK);
+    vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT);
     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-2025 The Khronos Group Inc.
-// Copyright 2023-2025 Valve Corporation
-// Copyright 2023-2025 LunarG, Inc.
+// Copyright 2023 The Khronos Group Inc.
+// Copyright 2023 Valve Corporation
+// Copyright 2023 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);
-    vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x4_SRGB_BLOCK);
+    vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT);
     struct VKU_FORMAT_INFO f = vkuGetFormatInfo(VK_FORMAT_R8G8B8A8_SRGB);
     if (f.component_count != 4) {
         return false;

tests/safe_struct.cpp

@@ -1,240 +0,0 @@
-// 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

@@ -1,415 +0,0 @@
-// 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

@@ -1,43 +0,0 @@
-// 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(static_cast<VkBufferCreateFlags>(VK_BUFFER_CREATE_SPARSE_BINDING_BIT), buffer_create_info.flags);
+    ASSERT_EQ(VK_BUFFER_CREATE_SPARSE_BINDING_BIT, buffer_create_info.flags);
     ASSERT_EQ(std::numeric_limits<uint64_t>::max(), buffer_create_info.size);
-    ASSERT_EQ(static_cast<VkBufferUsageFlags>(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), buffer_create_info.usage);
+    ASSERT_EQ(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, buffer_create_info.usage);
     ASSERT_EQ(VK_SHARING_MODE_EXCLUSIVE, buffer_create_info.sharingMode);
-    ASSERT_EQ(0u, buffer_create_info.queueFamilyIndexCount);
+    ASSERT_EQ(0, buffer_create_info.queueFamilyIndexCount);
     ASSERT_EQ(nullptr, buffer_create_info.pQueueFamilyIndices);
 }
 

tests/test_formats.cpp

@@ -1,6 +1,6 @@
-// Copyright 2023-2025 The Khronos Group Inc.
-// Copyright 2023-2025 Valve Corporation
-// Copyright 2023-2025 LunarG, Inc.
+// Copyright 2023 The Khronos Group Inc.
+// Copyright 2023 Valve Corporation
+// Copyright 2023 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), 16u);
+            EXPECT_EQ(vkuFormatDepthSize(format), 16);
         } else if (std::string::npos != format_str.find("_D24")) {
-            EXPECT_EQ(vkuFormatDepthSize(format), 24u);
+            EXPECT_EQ(vkuFormatDepthSize(format), 24);
         } else if (std::string::npos != format_str.find("_D32")) {
-            EXPECT_EQ(vkuFormatDepthSize(format), 32u);
+            EXPECT_EQ(vkuFormatDepthSize(format), 32);
         } else {
-            EXPECT_EQ(vkuFormatDepthSize(format), 0u);
+            EXPECT_EQ(vkuFormatDepthSize(format), 0);
         }
     }
 }
 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), 8u);
+            EXPECT_EQ(vkuFormatStencilSize(format), 8);
         } else {
-            EXPECT_EQ(vkuFormatStencilSize(format), 0u);
+            EXPECT_EQ(vkuFormatStencilSize(format), 0);
         }
     }
 }
@@ -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), 2u);
+            EXPECT_EQ(vkuFormatPlaneCount(format), 2);
         } else if (std::string::npos != format_str.find("3PLANE")) {
-            EXPECT_EQ(vkuFormatPlaneCount(format), 3u);
+            EXPECT_EQ(vkuFormatPlaneCount(format), 3);
         } else {
-            EXPECT_EQ(vkuFormatPlaneCount(format), 1u);
+            EXPECT_EQ(vkuFormatPlaneCount(format), 1);
         }
     }
 }
@@ -385,51 +385,31 @@ 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,
-        1u);
+        1);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_1_BIT).width,
-        2u);
+        2);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_2_BIT).width,
-        2u);
+        2);
 
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_0_BIT).height,
-        1u);
+        1);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_1_BIT).height,
-        2u);
+        2);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_2_BIT).height,
-        2u);
+        2);
 
-    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).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).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));
+    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);
 }
 
 TEST(format_utils, vkuFormatComponentCount) {
@@ -450,24 +430,24 @@ TEST(format_utils, vkuFormatTexelBlockExtent) {
     for (auto format : formats) {
         auto extent = vkuFormatTexelBlockExtent(format);
         if (vkuFormatIsCompressed(format)) {
-            EXPECT_GT(extent.width, 1u);
-            EXPECT_GT(extent.height, 1u);
-            EXPECT_EQ(extent.depth, 1u);
+            EXPECT_GT(extent.width, 1);
+            EXPECT_GT(extent.height, 1);
+            EXPECT_EQ(extent.depth, 1);
         } else if (format == VK_FORMAT_UNDEFINED) {
-            EXPECT_EQ(extent.width, 0u);
-            EXPECT_EQ(extent.height, 0u);
-            EXPECT_EQ(extent.depth, 0u);
+            EXPECT_EQ(extent.width, 0);
+            EXPECT_EQ(extent.height, 0);
+            EXPECT_EQ(extent.depth, 0);
             continue;
         } else {
-            EXPECT_EQ(extent.width, 1u);
-            EXPECT_EQ(extent.height, 1u);
-            EXPECT_EQ(extent.depth, 1u);
+            EXPECT_EQ(extent.width, 1);
+            EXPECT_EQ(extent.height, 1);
+            EXPECT_EQ(extent.depth, 1);
         }
     }
     auto extent = vkuFormatTexelBlockExtent(static_cast<VkFormat>(10001));
-    EXPECT_EQ(extent.width, 0u);
-    EXPECT_EQ(extent.height, 0u);
-    EXPECT_EQ(extent.depth, 0u);
+    EXPECT_EQ(extent.width, 0);
+    EXPECT_EQ(extent.height, 0);
+    EXPECT_EQ(extent.depth, 0);
 }
 TEST(format_utils, vkuFormatCompatibilityClass) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
@@ -523,29 +503,67 @@ TEST(format_utils, vkuFormatCompatibilityClass) {
         }
     }
 }
-
-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, 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, 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, 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, vkuFormatIs64bit) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (std::string::npos != format_str.find("R64")) {
@@ -631,12 +649,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), 0u);
+            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 0);
         } else if (std::string::npos != aspect_flag_str.find("_ASPECT_PLANE_1")) {
-            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 1u);
+            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 1);
 
         } else if (std::string::npos != aspect_flag_str.find("_ASPECT_PLANE_2")) {
-            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 2u);
+            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 2);
         } else {
             EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), VKU_FORMAT_INVALID_INDEX);
         }

tests/test_interface.cpp

@@ -44,13 +44,11 @@ TEST(test_vk_dispatch_table, cpp_interface) {
 
     vkuInitInstanceDispatchTable(instance, &instance_dispatch_table, local_vkGetInstanceProcAddr);
 
-    ASSERT_EQ(reinterpret_cast<PFN_vkVoidFunction>(instance_dispatch_table.GetInstanceProcAddr),
-              reinterpret_cast<PFN_vkVoidFunction>(local_vkGetInstanceProcAddr));
+    ASSERT_EQ(instance_dispatch_table.GetInstanceProcAddr, local_vkGetInstanceProcAddr);
 
     VkDevice device{};
 
     vkuInitDeviceDispatchTable(device, &device_dispatch_table, local_vkGetDeviceProcAddr);
 
-    ASSERT_EQ(reinterpret_cast<PFN_vkVoidFunction>(device_dispatch_table.GetDeviceProcAddr),
-              reinterpret_cast<PFN_vkVoidFunction>(local_vkGetDeviceProcAddr));
+    ASSERT_EQ(device_dispatch_table.GetDeviceProcAddr, 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(2u, value_count);
+    EXPECT_EQ(2, value_count);
 
     std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
 
-    value_count = 1u;
+    value_count = 1;
     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(1u, value_count);
+    EXPECT_EQ(1, value_count);
 
-    value_count = 2u;
+    value_count = 2;
     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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(76u, values[0]);
-    EXPECT_EQ(0u, values[1]);
-    EXPECT_EQ(1u, value_count);
+    EXPECT_EQ(76, values[0]);
+    EXPECT_EQ(0, values[1]);
+    EXPECT_EQ(1, 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(76u, values[0]);
-    EXPECT_EQ(82u, values[1]);
-    EXPECT_EQ(2u, value_count);
+    EXPECT_EQ(76, values[0]);
+    EXPECT_EQ(82, values[1]);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(76u, values[0].first);
-    EXPECT_EQ(100u, values[0].count);
-    EXPECT_EQ(10u, values[0].step);
-    EXPECT_EQ(1u, value_count);
+    EXPECT_EQ(76, values[0].first);
+    EXPECT_EQ(100, values[0].count);
+    EXPECT_EQ(10, values[0].step);
+    EXPECT_EQ(1, 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(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);
+    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);
 
     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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(76u, values[0]);
-    EXPECT_EQ(82u, values[1]);
-    EXPECT_EQ(2u, value_count);
+    EXPECT_EQ(76, values[0]);
+    EXPECT_EQ(82, values[1]);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(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);
+    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);
 
     value_count = 0;
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, nullptr);
-    EXPECT_EQ(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(76u, pValues);
+    EXPECT_EQ(76, 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(76u, values[0]);
-    EXPECT_EQ(82u, values[1]);
-    EXPECT_EQ(2u, values.size());
+    EXPECT_EQ(76, values[0]);
+    EXPECT_EQ(82, values[1]);
+    EXPECT_EQ(2, 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(76u, pValues.first);
-    EXPECT_EQ(100u, pValues.count);
-    EXPECT_EQ(10u, pValues.step);
+    EXPECT_EQ(76, pValues.first);
+    EXPECT_EQ(100, pValues.count);
+    EXPECT_EQ(10, 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(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(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, 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(0x76u, values[0].first);
-    EXPECT_EQ(0x82u, values[0].second);
-    EXPECT_EQ(76u, values[1].first);
-    EXPECT_EQ(82u, values[1].second);
+    EXPECT_EQ(0x76, values[0].first);
+    EXPECT_EQ(0x82, values[0].second);
+    EXPECT_EQ(76, values[1].first);
+    EXPECT_EQ(82, 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(2u, value_count_a);
+    EXPECT_EQ(2, 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(2u, value_count_a);
+    EXPECT_EQ(2, 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(2u, value_count_b);
+    EXPECT_EQ(2, 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(2u, value_count_b);
+    EXPECT_EQ(2, 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(2u, value_count_c);
+    EXPECT_EQ(2, 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(2u, value_count_c);
+    EXPECT_EQ(2, 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(2u, value_count_c);
+    EXPECT_EQ(2, 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(2u, value_count_c);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(76u, values[0]);
-    EXPECT_EQ(0u, values[1]);
-    EXPECT_EQ(1u, value_count);
+    EXPECT_EQ(76, values[0]);
+    EXPECT_EQ(0, values[1]);
+    EXPECT_EQ(1, 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(76u, values[0]);
-    EXPECT_EQ(82u, values[1]);
-    EXPECT_EQ(2u, value_count);
+    EXPECT_EQ(76, values[0]);
+    EXPECT_EQ(82, values[1]);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(76u, values[0].first);
-    EXPECT_EQ(100u, values[0].count);
-    EXPECT_EQ(10u, values[0].step);
-    EXPECT_EQ(1u, value_count);
+    EXPECT_EQ(76, values[0].first);
+    EXPECT_EQ(100, values[0].count);
+    EXPECT_EQ(10, values[0].step);
+    EXPECT_EQ(1, 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(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);
+    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);
 
     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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(76u, values[0]);
-    EXPECT_EQ(0u, values[1]);
-    EXPECT_EQ(1u, value_count);
+    EXPECT_EQ(76, values[0]);
+    EXPECT_EQ(0, values[1]);
+    EXPECT_EQ(1, 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(76u, values[0]);
-    EXPECT_EQ(82u, values[1]);
-    EXPECT_EQ(2u, value_count);
+    EXPECT_EQ(76, values[0]);
+    EXPECT_EQ(82, values[1]);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(2u, value_count);
+    EXPECT_EQ(2, 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(76u, values[0].first);
-    EXPECT_EQ(100u, values[0].count);
-    EXPECT_EQ(10u, values[0].step);
-    EXPECT_EQ(1u, value_count);
+    EXPECT_EQ(76, values[0].first);
+    EXPECT_EQ(100, values[0].count);
+    EXPECT_EQ(10, values[0].step);
+    EXPECT_EQ(1, 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(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);
+    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);
 
     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(2u, value_count);
+    EXPECT_EQ(2, 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(1u, value_count);
+    EXPECT_EQ(1, 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(2u, value_count);
+    EXPECT_EQ(2, 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(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"));
+    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"));
 }
 
 TEST(test_layer_settings_util, ToUint64) {
-    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(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(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(0u, framesets[0].first);
-        EXPECT_EQ(1u, framesets[0].count);
-        EXPECT_EQ(1u, framesets[0].step);
+        EXPECT_EQ(0, framesets[0].first);
+        EXPECT_EQ(1, framesets[0].count);
+        EXPECT_EQ(1, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("76");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(76u, framesets[0].first);
-        EXPECT_EQ(1u, framesets[0].count);
-        EXPECT_EQ(1u, framesets[0].step);
+        EXPECT_EQ(76, framesets[0].first);
+        EXPECT_EQ(1, framesets[0].count);
+        EXPECT_EQ(1, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(0u, framesets[0].first);
-        EXPECT_EQ(2u, framesets[0].count);
-        EXPECT_EQ(1u, framesets[0].step);
+        EXPECT_EQ(0, framesets[0].first);
+        EXPECT_EQ(2, framesets[0].count);
+        EXPECT_EQ(1, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6,7");
         EXPECT_EQ(3, framesets.size());
 
-        EXPECT_EQ(0u, framesets[0].first);
-        EXPECT_EQ(2u, framesets[0].count);
-        EXPECT_EQ(1u, framesets[0].step);
+        EXPECT_EQ(0, framesets[0].first);
+        EXPECT_EQ(2, framesets[0].count);
+        EXPECT_EQ(1, framesets[0].step);
 
-        EXPECT_EQ(6u, framesets[1].first);
-        EXPECT_EQ(1u, framesets[1].count);
-        EXPECT_EQ(1u, framesets[1].step);
+        EXPECT_EQ(6, framesets[1].first);
+        EXPECT_EQ(1, framesets[1].count);
+        EXPECT_EQ(1, framesets[1].step);
 
-        EXPECT_EQ(7u, framesets[2].first);
-        EXPECT_EQ(1u, framesets[2].count);
-        EXPECT_EQ(1u, framesets[2].step);
+        EXPECT_EQ(7, framesets[2].first);
+        EXPECT_EQ(1, framesets[2].count);
+        EXPECT_EQ(1, framesets[2].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6-7");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(0u, framesets[0].first);
-        EXPECT_EQ(2u, framesets[0].count);
-        EXPECT_EQ(1u, framesets[0].step);
+        EXPECT_EQ(0, framesets[0].first);
+        EXPECT_EQ(2, framesets[0].count);
+        EXPECT_EQ(1, framesets[0].step);
 
-        EXPECT_EQ(6u, framesets[1].first);
-        EXPECT_EQ(7u, framesets[1].count);
-        EXPECT_EQ(1u, framesets[1].step);
+        EXPECT_EQ(6, framesets[1].first);
+        EXPECT_EQ(7, framesets[1].count);
+        EXPECT_EQ(1, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-2,60,70");
         EXPECT_EQ(3, framesets.size());
 
-        EXPECT_EQ(1u, framesets[0].first);
-        EXPECT_EQ(2u, framesets[0].count);
-        EXPECT_EQ(1u, framesets[0].step);
+        EXPECT_EQ(1, framesets[0].first);
+        EXPECT_EQ(2, framesets[0].count);
+        EXPECT_EQ(1, framesets[0].step);
 
-        EXPECT_EQ(60u, framesets[1].first);
-        EXPECT_EQ(1u, framesets[1].count);
-        EXPECT_EQ(1u, framesets[1].step);
+        EXPECT_EQ(60, framesets[1].first);
+        EXPECT_EQ(1, framesets[1].count);
+        EXPECT_EQ(1, framesets[1].step);
 
-        EXPECT_EQ(70u, framesets[2].first);
-        EXPECT_EQ(1u, framesets[2].count);
-        EXPECT_EQ(1u, framesets[2].step);
+        EXPECT_EQ(70, framesets[2].first);
+        EXPECT_EQ(1, framesets[2].count);
+        EXPECT_EQ(1, framesets[2].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("10-20,60,70");
         EXPECT_EQ(3, framesets.size());
 
-        EXPECT_EQ(10u, framesets[0].first);
-        EXPECT_EQ(20u, framesets[0].count);
-        EXPECT_EQ(1u, framesets[0].step);
+        EXPECT_EQ(10, framesets[0].first);
+        EXPECT_EQ(20, framesets[0].count);
+        EXPECT_EQ(1, framesets[0].step);
 
-        EXPECT_EQ(60u, framesets[1].first);
-        EXPECT_EQ(1u, framesets[1].count);
-        EXPECT_EQ(1u, framesets[1].step);
+        EXPECT_EQ(60, framesets[1].first);
+        EXPECT_EQ(1, framesets[1].count);
+        EXPECT_EQ(1, framesets[1].step);
 
-        EXPECT_EQ(70u, framesets[2].first);
-        EXPECT_EQ(1u, framesets[2].count);
-        EXPECT_EQ(1u, framesets[2].step);
+        EXPECT_EQ(70, framesets[2].first);
+        EXPECT_EQ(1, framesets[2].count);
+        EXPECT_EQ(1, framesets[2].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(1u, framesets[0].first);
-        EXPECT_EQ(8u, framesets[0].count);
-        EXPECT_EQ(2u, framesets[0].step);
+        EXPECT_EQ(1, framesets[0].first);
+        EXPECT_EQ(8, framesets[0].count);
+        EXPECT_EQ(2, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,0");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1u, framesets[0].first);
-        EXPECT_EQ(8u, framesets[0].count);
-        EXPECT_EQ(2u, framesets[0].step);
+        EXPECT_EQ(1, framesets[0].first);
+        EXPECT_EQ(8, framesets[0].count);
+        EXPECT_EQ(2, framesets[0].step);
 
-        EXPECT_EQ(0u, framesets[1].first);
-        EXPECT_EQ(1u, framesets[1].count);
-        EXPECT_EQ(1u, framesets[1].step);
+        EXPECT_EQ(0, framesets[1].first);
+        EXPECT_EQ(1, framesets[1].count);
+        EXPECT_EQ(1, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-5");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1u, framesets[0].first);
-        EXPECT_EQ(8u, framesets[0].count);
-        EXPECT_EQ(2u, framesets[0].step);
+        EXPECT_EQ(1, framesets[0].first);
+        EXPECT_EQ(8, framesets[0].count);
+        EXPECT_EQ(2, framesets[0].step);
 
-        EXPECT_EQ(10u, framesets[1].first);
-        EXPECT_EQ(20u, framesets[1].count);
-        EXPECT_EQ(5u, framesets[1].step);
+        EXPECT_EQ(10, framesets[1].first);
+        EXPECT_EQ(20, framesets[1].count);
+        EXPECT_EQ(5, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8,10-20-5");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1u, framesets[0].first);
-        EXPECT_EQ(8u, framesets[0].count);
-        EXPECT_EQ(1u, framesets[0].step);
+        EXPECT_EQ(1, framesets[0].first);
+        EXPECT_EQ(8, framesets[0].count);
+        EXPECT_EQ(1, framesets[0].step);
 
-        EXPECT_EQ(10u, framesets[1].first);
-        EXPECT_EQ(20u, framesets[1].count);
-        EXPECT_EQ(5u, framesets[1].step);
+        EXPECT_EQ(10, framesets[1].first);
+        EXPECT_EQ(20, framesets[1].count);
+        EXPECT_EQ(5, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-1");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1u, framesets[0].first);
-        EXPECT_EQ(8u, framesets[0].count);
-        EXPECT_EQ(2u, framesets[0].step);
+        EXPECT_EQ(1, framesets[0].first);
+        EXPECT_EQ(8, framesets[0].count);
+        EXPECT_EQ(2, framesets[0].step);
 
-        EXPECT_EQ(10u, framesets[1].first);
-        EXPECT_EQ(20u, framesets[1].count);
-        EXPECT_EQ(1u, framesets[1].step);
+        EXPECT_EQ(10, framesets[1].first);
+        EXPECT_EQ(20, framesets[1].count);
+        EXPECT_EQ(1, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1,2,3,4");
         EXPECT_EQ(4, framesets.size());
 
-        EXPECT_EQ(1u, framesets[0].first);
-        EXPECT_EQ(1u, framesets[0].count);
-        EXPECT_EQ(1u, framesets[0].step);
+        EXPECT_EQ(1, framesets[0].first);
+        EXPECT_EQ(1, framesets[0].count);
+        EXPECT_EQ(1, framesets[0].step);
 
-        EXPECT_EQ(2u, framesets[1].first);
-        EXPECT_EQ(1u, framesets[1].count);
-        EXPECT_EQ(1u, framesets[1].step);
+        EXPECT_EQ(2, framesets[1].first);
+        EXPECT_EQ(1, framesets[1].count);
+        EXPECT_EQ(1, framesets[1].step);
 
-        EXPECT_EQ(3u, framesets[2].first);
-        EXPECT_EQ(1u, framesets[2].count);
-        EXPECT_EQ(1u, framesets[2].step);
+        EXPECT_EQ(3, framesets[2].first);
+        EXPECT_EQ(1, framesets[2].count);
+        EXPECT_EQ(1, framesets[2].step);
 
-        EXPECT_EQ(4u, framesets[3].first);
-        EXPECT_EQ(1u, framesets[3].count);
-        EXPECT_EQ(1u, framesets[3].step);
+        EXPECT_EQ(4, framesets[3].first);
+        EXPECT_EQ(1, framesets[3].count);
+        EXPECT_EQ(1, 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(2u, unknown_settings_count);
+    EXPECT_EQ(2, 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(1u, unknown_settings_count);
+    EXPECT_EQ(1, 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(2u, unknown_settings_count);
+    EXPECT_EQ(2, 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(1u, unknown_settings_count);
+    EXPECT_EQ(1, unknown_settings_count);
     EXPECT_STREQ("bool_value", unknown_settings[0]);
 
     unknown_settings_count = 2;