add tools/Vulkan-Tools

17 files changed, 5153 insertions, 0 deletions

diff --git a/tools/Vulkan-Tools/scripts/CMakeLists.txt b/tools/Vulkan-Tools/scripts/CMakeLists.txt
new file mode 100644
index 00000000..65c8bade
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/CMakeLists.txt
@@ -0,0 +1,135 @@
+# ~~~
+# Copyright (c) 2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ~~~
+
+option(UPDATE_DEPS "Run update_deps.py for user")
+if (UPDATE_DEPS)
+    find_package(Python3 REQUIRED QUIET)
+
+    set(update_dep_py "${CMAKE_CURRENT_LIST_DIR}/update_deps.py")
+    set(known_good_json "${CMAKE_CURRENT_LIST_DIR}/known_good.json")
+
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${update_dep_py} ${known_good_json})
+
+    list(APPEND update_dep_command "${update_dep_py}")
+    list(APPEND update_dep_command "--generator")
+    list(APPEND update_dep_command "${CMAKE_GENERATOR}")
+
+    if (CMAKE_GENERATOR_PLATFORM)
+        list(APPEND update_dep_command "--arch")
+        list(APPEND update_dep_command "${CMAKE_GENERATOR_PLATFORM}")
+    endif()
+
+    if (NOT CMAKE_BUILD_TYPE)
+        message(WARNING "CMAKE_BUILD_TYPE not set. Using Debug for dependency build type")
+        set(_build_type Debug)
+    else()
+        set(_build_type ${CMAKE_BUILD_TYPE})
+    endif()
+    list(APPEND update_dep_command "--config")
+    list(APPEND update_dep_command "${_build_type}")
+    list(APPEND update_dep_command "--api")
+    list(APPEND update_dep_command "${API_TYPE}")
+
+    set(UPDATE_DEPS_DIR_SUFFIX "${_build_type}")
+    if (CMAKE_CROSSCOMPILING)
+        set(UPDATE_DEPS_DIR_SUFFIX "${CMAKE_SYSTEM_NAME}/${UPDATE_DEPS_DIR_SUFFIX}/${CMAKE_SYSTEM_PROCESSOR}")
+    else()
+        math(EXPR bitness "8 * ${CMAKE_SIZEOF_VOID_P}")
+        set(UPDATE_DEPS_DIR_SUFFIX "${UPDATE_DEPS_DIR_SUFFIX}/${bitness}")
+    endif()
+    set(UPDATE_DEPS_DIR "${PROJECT_SOURCE_DIR}/external/${UPDATE_DEPS_DIR_SUFFIX}" CACHE PATH "Location where update_deps.py installs packages")
+    list(APPEND update_dep_command "--dir" )
+    list(APPEND update_dep_command "${UPDATE_DEPS_DIR}")
+
+    if (NOT BUILD_TESTS)
+        list(APPEND update_dep_command "--optional=tests")
+    endif()
+
+    if (UPDATE_DEPS_SKIP_EXISTING_INSTALL)
+        list(APPEND update_dep_command "--skip-existing-install")
+    endif()
+
+    list(APPEND cmake_vars "CMAKE_TOOLCHAIN_FILE")
+
+    # Avoids manually setting CMAKE_SYSTEM_NAME unless it's needed:
+    # https://cmake.org/cmake/help/latest/variable/CMAKE_CROSSCOMPILING.html
+    if (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "${CMAKE_HOST_SYSTEM_NAME}")
+        list(APPEND cmake_vars "CMAKE_SYSTEM_NAME")
+    endif()
+    if (APPLE)
+        list(APPEND cmake_vars "CMAKE_OSX_ARCHITECTURES" "CMAKE_OSX_DEPLOYMENT_TARGET")
+    endif()
+    if (NOT MSVC_IDE)
+        list(APPEND cmake_vars "CMAKE_CXX_COMPILER" "CMAKE_C_COMPILER" "CMAKE_ASM_COMPILER")
+    endif()
+    if (ANDROID)
+        list(APPEND cmake_vars "ANDROID_PLATFORM" "CMAKE_ANDROID_ARCH_ABI" "CMAKE_ANDROID_STL_TYPE" "CMAKE_ANDROID_RTTI" "CMAKE_ANDROID_EXCEPTIONS" "ANDROID_USE_LEGACY_TOOLCHAIN_FILE")
+    endif()
+
+    set(cmake_var)
+    foreach(var IN LISTS cmake_vars)
+        if (DEFINED ${var})
+            list(APPEND update_dep_command "--cmake_var")
+            list(APPEND update_dep_command "${var}=${${var}}")
+        endif()
+    endforeach()
+
+    if (cmake_var)
+        list(APPEND update_dep_command "${cmake_var}")
+    endif()
+
+    file(TIMESTAMP ${update_dep_py} timestamp_1)
+    file(TIMESTAMP ${known_good_json} timestamp_2)
+
+    string("MD5" md5_hash "${timestamp_1}-${timestamp_2}-${update_dep_command}")
+
+    set(UPDATE_DEPS_HASH "0" CACHE STRING "Default value until we run update_deps.py")
+    mark_as_advanced(UPDATE_DEPS_HASH)
+
+    if ("${UPDATE_DEPS_HASH}" STREQUAL "0")
+        list(APPEND update_dep_command "--clean-build")
+        list(APPEND update_dep_command "--clean-install")
+    endif()
+
+    if ("${md5_hash}" STREQUAL $CACHE{UPDATE_DEPS_HASH})
+        message(DEBUG "update_deps.py: no work to do.")
+    else()
+        execute_process(
+            COMMAND ${Python3_EXECUTABLE} ${update_dep_command}
+            RESULT_VARIABLE _update_deps_result
+        )
+        if (NOT (${_update_deps_result} EQUAL 0))
+            message(FATAL_ERROR "Could not run update_deps.py which is necessary to download dependencies.")
+        endif()
+        set(UPDATE_DEPS_HASH ${md5_hash} CACHE STRING "Ensure we only run update_deps.py when we need to." FORCE)
+        include("${UPDATE_DEPS_DIR}/helper.cmake")
+    endif()
+endif()
+if (VULKAN_HEADERS_INSTALL_DIR)
+    list(APPEND CMAKE_PREFIX_PATH ${VULKAN_HEADERS_INSTALL_DIR})
+endif()
+if (GOOGLETEST_INSTALL_DIR)
+    list(APPEND CMAKE_PREFIX_PATH ${GOOGLETEST_INSTALL_DIR})
+endif()
+if (VULKAN_LOADER_INSTALL_DIR)
+    list(APPEND CMAKE_PREFIX_PATH ${VULKAN_LOADER_INSTALL_DIR})
+endif()
+
+if (CMAKE_CROSSCOMPILING)
+    set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${CMAKE_PREFIX_PATH} PARENT_SCOPE)
+else()
+    set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} PARENT_SCOPE)
+endif()
diff --git a/tools/Vulkan-Tools/scripts/android.py b/tools/Vulkan-Tools/scripts/android.py
new file mode 100755
index 00000000..20cc69d4
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/android.py
@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+# Copyright (c) 2023 Valve Corporation
+# Copyright (c) 2023 LunarG, Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# NOTE: Android this documentation is crucial for understanding the layout of the NDK.
+# https://android.googlesource.com/platform/ndk/+/master/docs/BuildSystemMaintainers.md
+
+# NOTE: Environment variables we can rely on users/environments setting.
+# https://github.com/actions/runner-images/blob/main/images/linux/Ubuntu2204-Readme.md#environment-variables-2
+
+import argparse
+import os
+import sys
+import shutil
+import subprocess
+
+# 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)
+
+# 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(" ")
+
+    if verbose:
+        print(f'CICMD({cmd_list}, env={env})')
+    subprocess.check_call(cmd_list, cwd=start_dir, env=env)
+
+# Manifest file describing out test application
+def get_android_manifest() -> str:
+    manifest = RepoRelative('cube/android/AndroidManifest.xml')
+    if not os.path.isfile(manifest):
+        print(f"Unable to find manifest for APK! {manifest}")
+        sys.exit(-1)
+    return manifest
+
+# Generate the APK from the CMake binaries
+def generate_apk(SDK_ROOT : str, CMAKE_INSTALL_DIR : str) -> str:
+    apk_dir = RepoRelative('build-android/bin')
+
+    # Delete APK directory since it could contain files from old runs
+    if os.path.isdir(apk_dir):
+        shutil.rmtree(apk_dir)
+
+    shutil.copytree(CMAKE_INSTALL_DIR, apk_dir)
+
+    android_manifest = get_android_manifest()
+
+    android_jar = f"{SDK_ROOT}/platforms/android-26/android.jar"
+    if not os.path.isfile(android_jar):
+        print(f"Unable to find {android_jar}!")
+        sys.exit(-1)
+
+    apk_name = 'VkCube'
+
+    unaligned_apk = f'{apk_dir}/{apk_name}-unaligned.apk'
+    test_apk = f'{apk_dir}/{apk_name}.apk'
+
+    # Create APK
+    RunShellCmd(f'aapt package -f -M {android_manifest} -I {android_jar} -F {unaligned_apk} {CMAKE_INSTALL_DIR}')
+
+    # Align APK
+    RunShellCmd(f'zipalign -f 4 {unaligned_apk} {test_apk}')
+
+    # Create Key (If it doesn't already exist)
+    debug_key = RepoRelative(f'{apk_dir}/debug.keystore')
+    ks_pass = 'android'
+    if not os.path.isfile(debug_key):
+        dname = 'CN=Android-Debug,O=Android,C=US'
+        RunShellCmd(f'keytool -genkey -v -keystore {debug_key} -alias androiddebugkey -storepass {ks_pass} -keypass {ks_pass} -keyalg RSA -keysize 2048 -validity 10000 -dname {dname}')
+
+    # Sign APK
+    RunShellCmd(f'apksigner sign --verbose --ks {debug_key} --ks-pass pass:{ks_pass} {test_apk}')
+
+# Android APKs can contain binaries for multiple ABIs (armeabi-v7a, arm64-v8a, x86, x86_64).
+# https://en.wikipedia.org/wiki/Apk_(file_format)#Package_contents
+#
+# As a result CMake will need to be run multiple times to create a complete test APK that can be run on any Android device.
+def main():
+    configs = ['Release', 'Debug']
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', type=str, choices=configs, default=configs[0])
+    parser.add_argument('--app-abi', dest='android_abi', type=str, default="arm64-v8a")
+    parser.add_argument('--app-stl', dest='android_stl', type=str, choices=["c++_static", "c++_shared"], default="c++_static")
+    parser.add_argument('--apk', action='store_true', help='Generate an APK as a post build step.')
+    parser.add_argument('--clean', action='store_true', help='Cleans CMake build artifacts')
+    args = parser.parse_args()
+
+    cmake_config = args.config
+    android_abis = args.android_abi.split(" ")
+    android_stl = args.android_stl
+    create_apk = args.apk
+    clean = args.clean
+
+    if "ANDROID_NDK_HOME" not in os.environ:
+        print("Cannot find ANDROID_NDK_HOME!")
+        sys.exit(1)
+
+    android_ndk_home = os.environ.get('ANDROID_NDK_HOME')
+    android_toolchain = f'{android_ndk_home}/build/cmake/android.toolchain.cmake'
+
+    # The only tool we require for building is CMake/Ninja
+    required_cli_tools = ['cmake', 'ninja']
+
+    # If we are building an APK we need a few more tools.
+    if create_apk:
+        if "ANDROID_SDK_ROOT" not in os.environ:
+            print("Cannot find ANDROID_SDK_ROOT!")
+            sys.exit(1)
+
+        android_sdk_root = os.environ.get('ANDROID_SDK_ROOT')
+        print(f"ANDROID_SDK_ROOT = {android_sdk_root}")
+        required_cli_tools += ['aapt', 'zipalign', 'keytool', 'apksigner']
+
+    print(f"ANDROID_NDK_HOME = {android_ndk_home}")
+    print(f"Build configured for {cmake_config} | {android_stl} | {android_abis} | APK {create_apk}")
+
+    if not os.path.isfile(android_toolchain):
+        print(f'Unable to find android.toolchain.cmake at {android_toolchain}')
+        exit(-1)
+
+    for tool in required_cli_tools:
+        path = shutil.which(tool)
+        if path is None:
+            print(f"Unable to find {tool}!")
+            exit(-1)
+
+        print(f"Using {tool} : {path}")
+
+    cmake_install_dir = RepoRelative('build-android/libs')
+
+    # Delete install directory since it could contain files from old runs
+    if os.path.isdir(cmake_install_dir):
+        print("Cleaning CMake install")
+        shutil.rmtree(cmake_install_dir)
+
+    for abi in android_abis:
+        build_dir = RepoRelative(f'build-android/cmake/{abi}')
+        lib_dir = f'lib/{abi}'
+
+        if clean:
+            print("Deleting CMakeCache.txt")
+
+            # Delete CMakeCache.txt to ensure clean builds
+            # NOTE: CMake 3.24 has --fresh which would be better to use in the future.
+            cmake_cache = f'{build_dir}/CMakeCache.txt'
+            if os.path.isfile(cmake_cache):
+                os.remove(cmake_cache)
+
+        cmake_cmd =  f'cmake -S . -B {build_dir} -G Ninja'
+
+        cmake_cmd += f' -D CMAKE_BUILD_TYPE={cmake_config}'
+        cmake_cmd += f' -D UPDATE_DEPS=ON -D UPDATE_DEPS_DIR={build_dir}'
+        cmake_cmd += f' -D CMAKE_TOOLCHAIN_FILE={android_toolchain}'
+        cmake_cmd += f' -D CMAKE_ANDROID_ARCH_ABI={abi}'
+        cmake_cmd += f' -D CMAKE_INSTALL_LIBDIR={lib_dir}'
+        cmake_cmd += f' -D CMAKE_ANDROID_STL_TYPE={android_stl}'
+
+        cmake_cmd += ' -D ANDROID_PLATFORM=26'
+        cmake_cmd += ' -D ANDROID_USE_LEGACY_TOOLCHAIN_FILE=NO'
+
+        RunShellCmd(cmake_cmd)
+
+        build_cmd = f'cmake --build {build_dir}'
+        RunShellCmd(build_cmd)
+
+        install_cmd = f'cmake --install {build_dir} --prefix {cmake_install_dir}'
+        RunShellCmd(install_cmd)
+
+    if create_apk:
+        generate_apk(SDK_ROOT = android_sdk_root, CMAKE_INSTALL_DIR = cmake_install_dir)
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/Vulkan-Tools/scripts/common_codegen.py b/tools/Vulkan-Tools/scripts/common_codegen.py
new file mode 100644
index 00000000..d44cd643
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/common_codegen.py
@@ -0,0 +1,114 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2017, 2019-2021 The Khronos Group Inc.
+# Copyright (c) 2015-2017, 2019-2021 Valve Corporation
+# Copyright (c) 2015-2017, 2019-2021 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Mark Lobodzinski <mark@lunarg.com>
+
+import os
+import sys
+import subprocess
+
+# Copyright text prefixing all headers (list of strings).
+prefixStrings = [
+    '/*',
+    '** Copyright (c) 2015-2017, 2019-2021 The Khronos Group Inc.',
+    '** Copyright (c) 2015-2017, 2019-2021 Valve Corporation',
+    '** Copyright (c) 2015-2017, 2019-2021 LunarG, Inc.',
+    '** Copyright (c) 2015-2017, 2019-2021 Google Inc.',
+    '**',
+    '** Licensed under the Apache License, Version 2.0 (the "License");',
+    '** you may not use this file except in compliance with the License.',
+    '** You may obtain a copy of the License at',
+    '**',
+    '**     http://www.apache.org/licenses/LICENSE-2.0',
+    '**',
+    '** Unless required by applicable law or agreed to in writing, software',
+    '** distributed under the License is distributed on an "AS IS" BASIS,',
+    '** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.',
+    '** See the License for the specific language governing permissions and',
+    '** limitations under the License.',
+    '*/',
+    ''
+]
+
+
+platform_dict = {
+    'android' : 'VK_USE_PLATFORM_ANDROID_KHR',
+    'fuchsia' : 'VK_USE_PLATFORM_FUCHSIA',
+    'ggp': 'VK_USE_PLATFORM_GGP',
+    'ios' : 'VK_USE_PLATFORM_IOS_MVK',
+    'macos' : 'VK_USE_PLATFORM_MACOS_MVK',
+    'metal' : 'VK_USE_PLATFORM_METAL_EXT',
+    'vi' : 'VK_USE_PLATFORM_VI_NN',
+    'wayland' : 'VK_USE_PLATFORM_WAYLAND_KHR',
+    'win32' : 'VK_USE_PLATFORM_WIN32_KHR',
+    'xcb' : 'VK_USE_PLATFORM_XCB_KHR',
+    'xlib' : 'VK_USE_PLATFORM_XLIB_KHR',
+    'xlib_xrandr' : 'VK_USE_PLATFORM_XLIB_XRANDR_EXT',
+    'provisional' : 'VK_ENABLE_BETA_EXTENSIONS',
+    'directfb' : 'VK_USE_PLATFORM_DIRECTFB_EXT',
+    'screen' : 'VK_USE_PLATFORM_SCREEN_QNX',
+    'sci' : 'VK_USE_PLATFORM_SCI',
+    'ohos' : 'VK_USE_PLATFORM_OHOS',
+}
+
+#
+# Return appropriate feature protect string from 'platform' tag on feature
+def GetFeatureProtect(interface):
+    """Get platform protection string"""
+    platform = interface.get('platform')
+    if platform is not None:
+        return platform_dict[platform]
+
+    provisional = interface.get('provisional')
+    if provisional == 'true':
+        return platform_dict['provisional']
+
+# 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
+
+# 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)
+
+# helper to define paths relative to the repo root
+def RepoRelative(path):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', path))
+
+# 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)
\ No newline at end of file
diff --git a/tools/Vulkan-Tools/scripts/generate_source.py b/tools/Vulkan-Tools/scripts/generate_source.py
new file mode 100755
index 00000000..59314533
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/generate_source.py
@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+# Copyright (c) 2019 The Khronos Group Inc.
+# Copyright (c) 2019 Valve Corporation
+# Copyright (c) 2019 LunarG, Inc.
+# Copyright (c) 2019 Google Inc.
+# Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# Copyright (c) 2023-2023 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Mike Schuchardt <mikes@lunarg.com>
+
+import argparse
+import filecmp
+import os
+import shutil
+import sys
+import re
+import tempfile
+import json
+import common_codegen
+
+from xml.etree import ElementTree
+
+# Because we have special logic to import the Registry from input arguments and the BaseGenerator comes from the registry, we have to delay defining it until *after*
+# the Registry has been imported. Yes this is awkward, but it was the least awkward way to make --verify work.
+generators = {}
+
+def RunGenerators(api: str, registry: str, video_registry: str, directory: str, styleFile: str, targetFilter: str, flatOutput: bool):
+
+    try:
+        common_codegen.RunShellCmd(f'clang-format --version')
+        has_clang_format = True
+    except:
+        has_clang_format = False
+    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
+    scripts = os.path.dirname(registry)
+    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 base_generator import BaseGeneratorOptions
+    from generators.mock_icd_generator import MockICDOutputGenerator
+    from generators.vulkan_tools_helper_file_generator import HelperFileOutputGenerator
+    from generators.vulkaninfo_generator import VulkanInfoGenerator
+
+    # 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)
+    SetTargetApiName(api)
+
+    # Generated directory and dispatch table helper file name may be API specific (e.g. Vulkan SC)
+    mock_icd_generated_directory = 'icd/generated'
+    vulkaninfo_generated_directory = 'vulkaninfo/generated'
+
+    generators.update({
+        'vk_typemap_helper.h': {
+            'generator' : HelperFileOutputGenerator,
+            'genCombined': False,
+            'directory' : mock_icd_generated_directory,
+        },
+        'function_declarations.h': {
+            'generator' : MockICDOutputGenerator,
+            'genCombined': False,
+            'directory' : mock_icd_generated_directory,
+        },
+        'function_definitions.h': {
+            'generator' : MockICDOutputGenerator,
+            'genCombined': False,
+            'directory' : mock_icd_generated_directory,
+        },
+        'vulkaninfo.hpp': {
+            'generator' : VulkanInfoGenerator,
+            'genCombined': False,
+            'directory' : vulkaninfo_generated_directory,
+        },
+    })
+
+    unknownTargets = [x for x in (targetFilter if targetFilter else []) if x not in generators.keys()]
+    if unknownTargets:
+        print(f'ERROR: No generator options for unknown target(s): {", ".join(unknownTargets)}', file=sys.stderr)
+        return 1
+
+    # Filter if --target is passed in
+    targets = [x for x in generators.keys() if not targetFilter or x in targetFilter]
+
+    for index, target in enumerate(targets, start=1):
+        print(f'[{index}|{len(targets)}] Generating {target}')
+
+        # First grab a class constructor object and create an instance
+        generator = generators[target]['generator']
+        gen = generator()
+
+        # This code and the 'genCombined' generator metadata is used by downstream
+        # users to generate code with all Vulkan APIs merged into the target API variant
+        # (e.g. Vulkan SC) when needed. The constructed apiList is also used to filter
+        # out non-applicable extensions later below.
+        apiList = [api]
+        if api != 'vulkan' and generators[target]['genCombined']:
+            SetMergedApiNames('vulkan')
+            apiList.append('vulkan')
+        else:
+            SetMergedApiNames(None)
+
+        # For people who want to generate all the files in a single director
+        if flatOutput:
+            outDirectory = os.path.abspath(os.path.join(directory))
+        else:
+            outDirectory = os.path.abspath(os.path.join(directory, generators[target]['directory']))
+
+        options = BaseGeneratorOptions(
+            customFileName  = target,
+            customDirectory = outDirectory)
+
+        if not os.path.exists(outDirectory):
+            os.makedirs(outDirectory)
+
+        # Create the registry object with the specified generator and generator
+        # options. The options are set before XML loading as they may affect it.
+        reg = Registry(gen, options)
+
+        # Parse the specified registry XML into an ElementTree object
+        tree = ElementTree.parse(registry)
+
+        # Load the XML tree into the registry object
+        reg.loadElementTree(tree)
+
+        # Set the path to the video registry so that videoStd is available
+        reg.genOpts.videoXmlPath = video_registry
+
+        # Finally, use the output generator to create the requested target
+        reg.apiGen()
+
+        # Run clang-format on the file
+        if has_clang_format and styleFile:
+            common_codegen.RunShellCmd(f'clang-format -i --style=file:{styleFile} {os.path.join(outDirectory, target)}')
+
+
+def main(argv):
+
+    # files to exclude from --verify check
+    verify_exclude = ['.clang-format'] # None currently
+
+    parser = argparse.ArgumentParser(description='Generate source code for this repository')
+    parser.add_argument('registry', metavar='REGISTRY_PATH', help='path to the Vulkan-Headers registry directory')
+    parser.add_argument('--api',
+                        default='vulkan',
+                        choices=['vulkan', 'vulkansc'],
+                        help='Specify API name to generate')
+    parser.add_argument('--generated-version', help='sets the header version used to generate the repo')
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--target', nargs='+', help='only generate file names passed in')
+    group.add_argument('-i', '--incremental', action='store_true', help='only update repo files that change')
+    group.add_argument('-v', '--verify', action='store_true', help='verify repo files match generator output')
+    group.add_argument('-o', action='store', dest='directory', help='Create target and related files in specified directory')
+    args = parser.parse_args(argv)
+
+    repo_dir = common_codegen.RepoRelative('.')
+
+    registry = os.path.abspath(os.path.join(args.registry,  'vk.xml'))
+    video_registry = os.path.abspath(os.path.join(args.registry,  'video.xml'))
+    if not os.path.isfile(registry) and 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
+        video_registry = os.path.abspath(os.path.join(args.registry,  'Vulkan-Headers/registry/video.xml'))
+        if not os.path.isfile(video_registry):
+            print(f'{video_registry} does not exist')
+            return -1
+
+    # Need pass style file incase running with --verify and it can't find the file automatically in the temp directory
+    style_file = os.path.join(repo_dir, '.clang-format')
+
+    # get directory where generators will run
+    if args.verify or args.incremental:
+        # generate in temp directory so we can compare or copy later
+        temp_obj = tempfile.TemporaryDirectory(prefix='vulkan_tools_codegen_')
+        temp_dir = temp_obj.name
+        gen_dir = temp_dir
+    elif args.directory:
+        gen_dir = args.directory
+    else:
+        # generate directly in the repo
+        gen_dir = repo_dir
+
+    RunGenerators(api=args.api,registry=registry, video_registry=video_registry, directory=gen_dir, styleFile=style_file, targetFilter=args.target, flatOutput=False)
+
+    # optional post-generation steps
+    if args.verify:
+        # compare contents of temp dir and repo
+        temp_files = {}
+        repo_files = {}
+        for details in generators.values():
+            if details['directory'] not in temp_files:
+                temp_files[details['directory']] = set()
+            temp_files[details['directory']].update(set(os.listdir(os.path.join(temp_dir, details['directory']))))
+            if details['directory'] not in repo_files:
+                repo_files[details['directory']] = set()
+            repo_files[details['directory']].update(set(os.listdir(os.path.join(repo_dir, details['directory']))) - set(verify_exclude))
+
+        # compare contents of temp dir and repo
+        files_match = True
+        for filename, details in generators.items():
+            if filename not in repo_files[details['directory']]:
+                print('ERROR: Missing repo file', filename)
+                files_match = False
+            elif filename not in temp_files[details['directory']]:
+                print('ERROR: Missing generator for', filename)
+                files_match = False
+            elif not filecmp.cmp(os.path.join(temp_dir, details['directory'], filename),
+                            os.path.join(repo_dir, details['directory'], filename),
+                            shallow=False):
+                print('ERROR: Repo files do not match generator output for', filename)
+                files_match = False
+
+        # return code for test scripts
+        if files_match:
+            print('SUCCESS: Repo files match generator output')
+            return 0
+        return 1
+
+    elif args.incremental:
+        # copy missing or differing files from temp directory to repo
+        for filename, details in generators.items():
+            temp_filename = os.path.join(temp_dir, details['directory'], filename)
+            repo_filename = os.path.join(repo_dir, details['directory'], filename)
+            if not os.path.exists(repo_filename) or \
+            not filecmp.cmp(temp_filename, repo_filename, shallow=False):
+                print('update', repo_filename)
+                shutil.copyfile(temp_filename, repo_filename)
+
+    # write out the header version used to generate the code to a checked in CMake file
+    if args.generated_version:
+        json_files = []
+        json_files.append(common_codegen.RepoRelative('icd/VkICD_mock_icd.json.in'))
+        for json_file in json_files:
+            with open(json_file) as f:
+                data = json.load(f)
+
+            data["ICD"]["api_version"] = args.generated_version
+
+            with open(json_file, mode='w', encoding='utf-8', newline='\n') as f:
+                f.write(json.dumps(data, indent=4))
+
+        # Update the CMake project version
+        with open(common_codegen.RepoRelative('CMakeLists.txt'), "r+") as f:
+            data = f.read()
+            f.seek(0)
+            f.write(re.sub("project.*VERSION.*", f"project(Vulkan-Tools VERSION {args.generated_version})", data))
+            f.truncate()
+
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))
+
diff --git a/tools/Vulkan-Tools/scripts/generators/mock_icd_generator.py b/tools/Vulkan-Tools/scripts/generators/mock_icd_generator.py
new file mode 100644
index 00000000..b1d81c42
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/generators/mock_icd_generator.py
@@ -0,0 +1,1452 @@
+#!/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.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Tobin Ehlis <tobine@google.com>
+#
+# This script generates a Mock ICD that intercepts almost all Vulkan
+#  functions. That layer is not intended to be useful or even compilable
+#  in its initial state. Rather it's intended to be a starting point that
+#  can be copied and customized to assist in creation of a new layer.
+
+from base_generator import BaseGenerator
+
+CUSTOM_C_INTERCEPTS = {
+'vkCreateInstance': '''
+    // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with
+    //  apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the
+    //  ICD should behave as normal.
+    if (loader_interface_version <= 4) {
+        return VK_ERROR_INCOMPATIBLE_DRIVER;
+    }
+    *pInstance = (VkInstance)CreateDispObjHandle();
+    for (auto& physical_device : physical_device_map[*pInstance])
+        physical_device = (VkPhysicalDevice)CreateDispObjHandle();
+    // TODO: If emulating specific device caps, will need to add intelligence here
+    return VK_SUCCESS;
+''',
+'vkDestroyInstance': '''
+    if (instance) {
+        for (const auto physical_device : physical_device_map.at(instance)) {
+            display_map.erase(physical_device);
+            DestroyDispObjHandle((void*)physical_device);
+        }
+        physical_device_map.erase(instance);
+        DestroyDispObjHandle((void*)instance);
+    }
+''',
+'vkAllocateCommandBuffers': '''
+    unique_lock_t lock(global_lock);
+    for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) {
+        pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle();
+        command_pool_buffer_map[pAllocateInfo->commandPool].push_back(pCommandBuffers[i]);
+    }
+    return VK_SUCCESS;
+''',
+'vkFreeCommandBuffers': '''
+    unique_lock_t lock(global_lock);
+    for (auto i = 0u; i < commandBufferCount; ++i) {
+        if (!pCommandBuffers[i]) {
+            continue;
+        }
+
+        for (auto& pair : command_pool_buffer_map) {
+            auto& cbs = pair.second;
+            auto it = std::find(cbs.begin(), cbs.end(), pCommandBuffers[i]);
+            if (it != cbs.end()) {
+                cbs.erase(it);
+            }
+        }
+
+        DestroyDispObjHandle((void*) pCommandBuffers[i]);
+    }
+''',
+'vkCreateCommandPool': '''
+    unique_lock_t lock(global_lock);
+    *pCommandPool = (VkCommandPool)global_unique_handle++;
+    command_pool_map[device].insert(*pCommandPool);
+    return VK_SUCCESS;
+''',
+'vkDestroyCommandPool': '''
+    // destroy command buffers for this pool
+    unique_lock_t lock(global_lock);
+    auto it = command_pool_buffer_map.find(commandPool);
+    if (it != command_pool_buffer_map.end()) {
+        for (auto& cb : it->second) {
+            DestroyDispObjHandle((void*) cb);
+        }
+        command_pool_buffer_map.erase(it);
+    }
+    command_pool_map[device].erase(commandPool);
+''',
+'vkEnumeratePhysicalDevices': '''
+    VkResult result_code = VK_SUCCESS;
+    if (pPhysicalDevices) {
+        const auto return_count = (std::min)(*pPhysicalDeviceCount, icd_physical_device_count);
+        for (uint32_t i = 0; i < return_count; ++i) pPhysicalDevices[i] = physical_device_map.at(instance)[i];
+        if (return_count < icd_physical_device_count) result_code = VK_INCOMPLETE;
+        *pPhysicalDeviceCount = return_count;
+    } else {
+        *pPhysicalDeviceCount = icd_physical_device_count;
+    }
+    return result_code;
+''',
+'vkCreateDevice': '''
+    *pDevice = (VkDevice)CreateDispObjHandle();
+    // TODO: If emulating specific device caps, will need to add intelligence here
+    return VK_SUCCESS;
+''',
+'vkDestroyDevice': '''
+    unique_lock_t lock(global_lock);
+    // First destroy sub-device objects
+    // Destroy Queues
+    for (auto queue_family_map_pair : queue_map[device]) {
+        for (auto index_queue_pair : queue_map[device][queue_family_map_pair.first]) {
+            DestroyDispObjHandle((void*)index_queue_pair.second);
+        }
+    }
+
+    for (auto& cp : command_pool_map[device]) {
+        for (auto& cb : command_pool_buffer_map[cp]) {
+            DestroyDispObjHandle((void*) cb);
+        }
+        command_pool_buffer_map.erase(cp);
+    }
+    command_pool_map[device].clear();
+
+    queue_map.erase(device);
+    buffer_map.erase(device);
+    image_memory_size_map.erase(device);
+    // Now destroy device
+    DestroyDispObjHandle((void*)device);
+    // TODO: If emulating specific device caps, will need to add intelligence here
+''',
+'vkGetDeviceQueue': '''
+    unique_lock_t lock(global_lock);
+    auto queue = queue_map[device][queueFamilyIndex][queueIndex];
+    if (queue) {
+        *pQueue = queue;
+    } else {
+        *pQueue = queue_map[device][queueFamilyIndex][queueIndex] = (VkQueue)CreateDispObjHandle();
+    }
+    // TODO: If emulating specific device caps, will need to add intelligence here
+    return;
+''',
+'vkGetDeviceQueue2': '''
+    GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue);
+    // TODO: Add further support for GetDeviceQueue2 features
+''',
+'vkEnumerateInstanceLayerProperties': '''
+    return VK_SUCCESS;
+''',
+'vkEnumerateInstanceVersion': '''
+    *pApiVersion = VK_HEADER_VERSION_COMPLETE;
+    return VK_SUCCESS;
+''',
+'vkEnumerateDeviceLayerProperties': '''
+    return VK_SUCCESS;
+''',
+'vkEnumerateInstanceExtensionProperties': '''
+    // If requesting number of extensions, return that
+    if (!pLayerName) {
+        if (!pProperties) {
+            *pPropertyCount = (uint32_t)instance_extension_map.size();
+        } else {
+            uint32_t i = 0;
+            for (const auto &name_ver_pair : instance_extension_map) {
+                if (i == *pPropertyCount) {
+                    break;
+                }
+                std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
+                pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
+                pProperties[i].specVersion = name_ver_pair.second;
+                ++i;
+            }
+            if (i != instance_extension_map.size()) {
+                return VK_INCOMPLETE;
+            }
+        }
+    }
+    // If requesting extension properties, fill in data struct for number of extensions
+    return VK_SUCCESS;
+''',
+'vkEnumerateDeviceExtensionProperties': '''
+    // If requesting number of extensions, return that
+    if (!pLayerName) {
+        if (!pProperties) {
+            *pPropertyCount = (uint32_t)device_extension_map.size();
+        } else {
+            uint32_t i = 0;
+            for (const auto &name_ver_pair : device_extension_map) {
+                if (i == *pPropertyCount) {
+                    break;
+                }
+                std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName));
+                pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0;
+                pProperties[i].specVersion = name_ver_pair.second;
+                ++i;
+            }
+            *pPropertyCount = i;
+            if (i != device_extension_map.size()) {
+                return VK_INCOMPLETE;
+            }
+        }
+    }
+    // If requesting extension properties, fill in data struct for number of extensions
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfacePresentModesKHR': '''
+    // Currently always say that all present modes are supported
+    if (!pPresentModes) {
+        *pPresentModeCount = 6;
+    } else {
+        if (*pPresentModeCount >= 6) pPresentModes[5] = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR;
+        if (*pPresentModeCount >= 5) pPresentModes[4] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR;
+        if (*pPresentModeCount >= 4) pPresentModes[3] = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
+        if (*pPresentModeCount >= 3) pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR;
+        if (*pPresentModeCount >= 2) pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR;
+        if (*pPresentModeCount >= 1) pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR;
+        *pPresentModeCount = *pPresentModeCount < 6 ? *pPresentModeCount : 6;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceFormatsKHR': '''
+    // Currently always say that RGBA8 & BGRA8 are supported
+    if (!pSurfaceFormats) {
+        *pSurfaceFormatCount = 2;
+    } else {
+        if (*pSurfaceFormatCount >= 2) {
+            pSurfaceFormats[1].format = VK_FORMAT_R8G8B8A8_UNORM;
+            pSurfaceFormats[1].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+        if (*pSurfaceFormatCount >= 1) {
+            pSurfaceFormats[0].format = VK_FORMAT_B8G8R8A8_UNORM;
+            pSurfaceFormats[0].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceFormats2KHR': '''
+    // Currently always say that RGBA8 & BGRA8 are supported
+    if (!pSurfaceFormats) {
+        *pSurfaceFormatCount = 2;
+    } else {
+        if (*pSurfaceFormatCount >= 2) {
+            pSurfaceFormats[1].pNext = nullptr;
+            pSurfaceFormats[1].surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;
+            pSurfaceFormats[1].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+        if (*pSurfaceFormatCount >= 1) {
+            pSurfaceFormats[1].pNext = nullptr;
+            pSurfaceFormats[0].surfaceFormat.format = VK_FORMAT_B8G8R8A8_UNORM;
+            pSurfaceFormats[0].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
+        }
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceSupportKHR': '''
+    // Currently say that all surface/queue combos are supported
+    *pSupported = VK_TRUE;
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceCapabilitiesKHR': '''
+    // In general just say max supported is available for requested surface
+    pSurfaceCapabilities->minImageCount = 1;
+    pSurfaceCapabilities->maxImageCount = 0;
+    pSurfaceCapabilities->currentExtent.width = 0xFFFFFFFF;
+    pSurfaceCapabilities->currentExtent.height = 0xFFFFFFFF;
+    pSurfaceCapabilities->minImageExtent.width = 1;
+    pSurfaceCapabilities->minImageExtent.height = 1;
+    pSurfaceCapabilities->maxImageExtent.width = 0xFFFF;
+    pSurfaceCapabilities->maxImageExtent.height = 0xFFFF;
+    pSurfaceCapabilities->maxImageArrayLayers = 128;
+    pSurfaceCapabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
+                                                VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
+    pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+    pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR |
+                                                    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR |
+                                                    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR |
+                                                    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
+    pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                                                VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                                                VK_IMAGE_USAGE_SAMPLED_BIT |
+                                                VK_IMAGE_USAGE_STORAGE_BIT |
+                                                VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                                                VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
+                                                VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT |
+                                                VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSurfaceCapabilities2KHR': '''
+    GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities);
+
+    auto *present_mode_compatibility = lvl_find_mod_in_chain<VkSurfacePresentModeCompatibilityEXT>(pSurfaceCapabilities->pNext);
+    if (present_mode_compatibility) {
+        if (!present_mode_compatibility->pPresentModes) {
+            present_mode_compatibility->presentModeCount = 3;
+        } else {
+            // arbitrary
+            present_mode_compatibility->pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR;
+            present_mode_compatibility->pPresentModes[1] = VK_PRESENT_MODE_FIFO_KHR;
+            present_mode_compatibility->pPresentModes[2] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR;
+        }
+    }
+    return VK_SUCCESS;
+''',
+'vkGetInstanceProcAddr': '''
+    if (!negotiate_loader_icd_interface_called) {
+        loader_interface_version = 0;
+    }
+    const auto &item = name_to_funcptr_map.find(pName);
+    if (item != name_to_funcptr_map.end()) {
+        return reinterpret_cast<PFN_vkVoidFunction>(item->second);
+    }
+    // Mock should intercept all functions so if we get here just return null
+    return nullptr;
+''',
+'vkGetDeviceProcAddr': '''
+    return GetInstanceProcAddr(nullptr, pName);
+''',
+'vkGetPhysicalDeviceMemoryProperties': '''
+    pMemoryProperties->memoryTypeCount = 6;
+    // Host visible Coherent
+    pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    pMemoryProperties->memoryTypes[0].heapIndex = 0;
+    // Host visible Cached
+    pMemoryProperties->memoryTypes[1].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+    pMemoryProperties->memoryTypes[1].heapIndex = 0;
+    // Device local and Host visible
+    pMemoryProperties->memoryTypes[2].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    pMemoryProperties->memoryTypes[2].heapIndex = 1;
+    // Device local lazily
+    pMemoryProperties->memoryTypes[3].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
+    pMemoryProperties->memoryTypes[3].heapIndex = 1;
+    // Device local protected
+    pMemoryProperties->memoryTypes[4].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_PROTECTED_BIT;
+    pMemoryProperties->memoryTypes[4].heapIndex = 1;
+    // Device local only
+    pMemoryProperties->memoryTypes[5].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+    pMemoryProperties->memoryTypes[5].heapIndex = 1;
+    pMemoryProperties->memoryHeapCount = 2;
+    pMemoryProperties->memoryHeaps[0].flags = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT;
+    pMemoryProperties->memoryHeaps[0].size = 8000000000;
+    pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
+    pMemoryProperties->memoryHeaps[1].size = 8000000000;
+''',
+'vkGetPhysicalDeviceMemoryProperties2KHR': '''
+    GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties);
+''',
+'vkGetPhysicalDeviceQueueFamilyProperties': '''
+    if (pQueueFamilyProperties) {
+        std::vector<VkQueueFamilyProperties2KHR> props2(*pQueueFamilyPropertyCount, {
+            VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR});
+        GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, props2.data());
+        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; ++i) {
+            pQueueFamilyProperties[i] = props2[i].queueFamilyProperties;
+        }
+    } else {
+        GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, nullptr);
+    }
+''',
+'vkGetPhysicalDeviceQueueFamilyProperties2KHR': '''
+    if (pQueueFamilyProperties) {
+        if (*pQueueFamilyPropertyCount >= 1) {
+            auto props = &pQueueFamilyProperties[0].queueFamilyProperties;
+            props->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT
+                                | VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_PROTECTED_BIT;
+            props->queueCount = 1;
+            props->timestampValidBits = 16;
+            props->minImageTransferGranularity = {1,1,1};
+        }
+        if (*pQueueFamilyPropertyCount >= 2) {
+            auto props = &pQueueFamilyProperties[1].queueFamilyProperties;
+            props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_DECODE_BIT_KHR;
+            props->queueCount = 1;
+            props->timestampValidBits = 16;
+            props->minImageTransferGranularity = {1,1,1};
+
+            auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[1].pNext);
+            if (status_query_props) {
+                status_query_props->queryResultStatusSupport = VK_TRUE;
+            }
+            auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[1].pNext);
+            if (video_props) {
+                video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR
+                                                  | VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR
+                                                  | VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR;
+            }
+        }
+        if (*pQueueFamilyPropertyCount >= 3) {
+            auto props = &pQueueFamilyProperties[2].queueFamilyProperties;
+            props->queueFlags = VK_QUEUE_TRANSFER_BIT | VK_QUEUE_PROTECTED_BIT | VK_QUEUE_VIDEO_ENCODE_BIT_KHR;
+            props->queueCount = 1;
+            props->timestampValidBits = 16;
+            props->minImageTransferGranularity = {1,1,1};
+
+            auto status_query_props = lvl_find_mod_in_chain<VkQueueFamilyQueryResultStatusPropertiesKHR>(pQueueFamilyProperties[2].pNext);
+            if (status_query_props) {
+                status_query_props->queryResultStatusSupport = VK_TRUE;
+            }
+            auto video_props = lvl_find_mod_in_chain<VkQueueFamilyVideoPropertiesKHR>(pQueueFamilyProperties[2].pNext);
+            if (video_props) {
+                video_props->videoCodecOperations = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR
+                                                  | VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR
+                                                  | VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR;
+            }
+        }
+        if (*pQueueFamilyPropertyCount > 3) {
+            *pQueueFamilyPropertyCount = 3;
+        }
+    } else {
+        *pQueueFamilyPropertyCount = 3;
+    }
+''',
+'vkGetPhysicalDeviceFeatures': '''
+    uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
+    VkBool32 *bool_array = &pFeatures->robustBufferAccess;
+    SetBoolArrayTrue(bool_array, num_bools);
+''',
+'vkGetPhysicalDeviceFeatures2KHR': '''
+    GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
+    uint32_t num_bools = 0; // Count number of VkBool32s in extension structs
+    VkBool32* feat_bools = nullptr;
+    auto vk_1_1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Features>(pFeatures->pNext);
+    if (vk_1_1_features) {
+        vk_1_1_features->protectedMemory = VK_TRUE;
+    }
+    auto vk_1_3_features = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Features>(pFeatures->pNext);
+    if (vk_1_3_features) {
+        vk_1_3_features->synchronization2 = VK_TRUE;
+    }
+    auto prot_features = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryFeatures>(pFeatures->pNext);
+    if (prot_features) {
+        prot_features->protectedMemory = VK_TRUE;
+    }
+    auto sync2_features = lvl_find_mod_in_chain<VkPhysicalDeviceSynchronization2FeaturesKHR>(pFeatures->pNext);
+    if (sync2_features) {
+        sync2_features->synchronization2 = VK_TRUE;
+    }
+    auto video_maintenance1_features = lvl_find_mod_in_chain<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>(pFeatures->pNext);
+    if (video_maintenance1_features) {
+        video_maintenance1_features->videoMaintenance1 = VK_TRUE;
+    }
+    const auto *desc_idx_features = lvl_find_in_chain<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(pFeatures->pNext);
+    if (desc_idx_features) {
+        const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing);
+        num_bools = bool_size/sizeof(VkBool32);
+        feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing;
+        SetBoolArrayTrue(feat_bools, num_bools);
+    }
+    const auto *blendop_features = lvl_find_in_chain<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(pFeatures->pNext);
+    if (blendop_features) {
+        const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations);
+        num_bools = bool_size/sizeof(VkBool32);
+        feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations;
+        SetBoolArrayTrue(feat_bools, num_bools);
+    }
+    const auto *host_image_copy_features = lvl_find_in_chain<VkPhysicalDeviceHostImageCopyFeaturesEXT>(pFeatures->pNext);
+    if (host_image_copy_features) {
+       feat_bools = (VkBool32*)&host_image_copy_features->hostImageCopy;
+       SetBoolArrayTrue(feat_bools, 1);
+    }
+''',
+'vkGetPhysicalDeviceFormatProperties': '''
+    if (VK_FORMAT_UNDEFINED == format) {
+        *pFormatProperties = { 0x0, 0x0, 0x0 };
+    } else {
+        // Default to a color format, skip DS bit
+        *pFormatProperties = { 0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF };
+        switch (format) {
+            case VK_FORMAT_D16_UNORM:
+            case VK_FORMAT_X8_D24_UNORM_PACK32:
+            case VK_FORMAT_D32_SFLOAT:
+            case VK_FORMAT_S8_UINT:
+            case VK_FORMAT_D16_UNORM_S8_UINT:
+            case VK_FORMAT_D24_UNORM_S8_UINT:
+            case VK_FORMAT_D32_SFLOAT_S8_UINT:
+                // Don't set color bits for DS formats
+                *pFormatProperties = { 0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F };
+                break;
+            case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+            case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+            case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+            case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+            case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM:
+                // Set decode/encode bits for these formats
+                *pFormatProperties = { 0x1EFFFDFF, 0x1EFFFDFF, 0x00FFFDFF };
+                break;
+            default:
+                break;
+        }
+    }
+''',
+'vkGetPhysicalDeviceFormatProperties2KHR': '''
+    GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties);
+    VkFormatProperties3KHR *props_3 = lvl_find_mod_in_chain<VkFormatProperties3KHR>(pFormatProperties->pNext);
+    if (props_3) {
+        props_3->linearTilingFeatures = pFormatProperties->formatProperties.linearTilingFeatures;
+        props_3->optimalTilingFeatures = pFormatProperties->formatProperties.optimalTilingFeatures;
+        props_3->bufferFeatures = pFormatProperties->formatProperties.bufferFeatures;
+        props_3->optimalTilingFeatures |= VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT;
+    }
+''',
+'vkGetPhysicalDeviceImageFormatProperties': '''
+    // A hardcoded unsupported format
+    if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
+        return VK_ERROR_FORMAT_NOT_SUPPORTED;
+    }
+
+    // TODO: Just hard-coding some values for now
+    // TODO: If tiling is linear, limit the mips, levels, & sample count
+    if (VK_IMAGE_TILING_LINEAR == tiling) {
+        *pImageFormatProperties = { { 4096, 4096, 256 }, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296 };
+    } else {
+        // We hard-code support for all sample counts except 64 bits.
+        *pImageFormatProperties = { { 4096, 4096, 256 }, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296 };
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceImageFormatProperties2KHR': '''
+    auto *external_image_prop = lvl_find_mod_in_chain<VkExternalImageFormatProperties>(pImageFormatProperties->pNext);
+    auto *external_image_format = lvl_find_in_chain<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo->pNext);
+    if (external_image_prop && external_image_format) {
+        external_image_prop->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
+        external_image_prop->externalMemoryProperties.compatibleHandleTypes = external_image_format->handleType;
+    }
+
+    GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties);
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceSparseImageFormatProperties': '''
+    if (!pProperties) {
+        *pPropertyCount = 1;
+    } else {
+        // arbitrary
+        pProperties->imageGranularity = {4, 4, 4};
+        pProperties->flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT;
+        switch (format) {
+            case VK_FORMAT_D16_UNORM:
+            case VK_FORMAT_D32_SFLOAT:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+                break;
+            case VK_FORMAT_S8_UINT:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
+                break;
+            case VK_FORMAT_X8_D24_UNORM_PACK32:
+            case VK_FORMAT_D16_UNORM_S8_UINT:
+            case VK_FORMAT_D24_UNORM_S8_UINT:
+            case VK_FORMAT_D32_SFLOAT_S8_UINT:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+                break;
+            default:
+                pProperties->aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+                break;
+        }
+    }
+''',
+'vkGetPhysicalDeviceSparseImageFormatProperties2KHR': '''
+    if (pPropertyCount && pProperties) {
+        GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, &pProperties->properties);
+    } else {
+        GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, nullptr);
+    }
+''',
+'vkGetPhysicalDeviceProperties': '''
+    pProperties->apiVersion = VK_HEADER_VERSION_COMPLETE;
+    pProperties->driverVersion = 1;
+    pProperties->vendorID = 0xba5eba11;
+    pProperties->deviceID = 0xf005ba11;
+    pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
+    //std::string devName = "Vulkan Mock Device";
+    strcpy(pProperties->deviceName, "Vulkan Mock Device");
+    pProperties->pipelineCacheUUID[0] = 18;
+    pProperties->limits = SetLimits(&pProperties->limits);
+    pProperties->sparseProperties = { VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE };
+''',
+'vkGetPhysicalDeviceProperties2KHR': '''
+    // The only value that need to be set are those the Profile layer can't set
+    // see https://github.com/KhronosGroup/Vulkan-Profiles/issues/352
+    // All values set are arbitrary
+    GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
+
+    auto *props_11 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan11Properties>(pProperties->pNext);
+    if (props_11) {
+        props_11->protectedNoFault = VK_FALSE;
+    }
+
+    auto *props_12 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan12Properties>(pProperties->pNext);
+    if (props_12) {
+        props_12->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+        props_12->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+    }
+
+    auto *props_13 = lvl_find_mod_in_chain<VkPhysicalDeviceVulkan13Properties>(pProperties->pNext);
+    if (props_13) {
+        props_13->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        props_13->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        props_13->storageTexelBufferOffsetAlignmentBytes = 16;
+        props_13->uniformTexelBufferOffsetAlignmentBytes = 16;
+    }
+
+    auto *protected_memory_props = lvl_find_mod_in_chain<VkPhysicalDeviceProtectedMemoryProperties>(pProperties->pNext);
+    if (protected_memory_props) {
+        protected_memory_props->protectedNoFault = VK_FALSE;
+    }
+
+    auto *float_controls_props = lvl_find_mod_in_chain<VkPhysicalDeviceFloatControlsProperties>(pProperties->pNext);
+    if (float_controls_props) {
+        float_controls_props->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+        float_controls_props->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
+    }
+
+    auto *conservative_raster_props = lvl_find_mod_in_chain<VkPhysicalDeviceConservativeRasterizationPropertiesEXT>(pProperties->pNext);
+    if (conservative_raster_props) {
+        conservative_raster_props->primitiveOverestimationSize = 0.00195313f;
+        conservative_raster_props->conservativePointAndLineRasterization = VK_TRUE;
+        conservative_raster_props->degenerateTrianglesRasterized = VK_TRUE;
+        conservative_raster_props->degenerateLinesRasterized = VK_TRUE;
+    }
+
+    auto *rt_pipeline_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPipelinePropertiesKHR>(pProperties->pNext);
+    if (rt_pipeline_props) {
+        rt_pipeline_props->shaderGroupHandleSize = 32;
+        rt_pipeline_props->shaderGroupBaseAlignment = 64;
+        rt_pipeline_props->shaderGroupHandleCaptureReplaySize = 32;
+    }
+
+    auto *rt_pipeline_nv_props = lvl_find_mod_in_chain<VkPhysicalDeviceRayTracingPropertiesNV>(pProperties->pNext);
+    if (rt_pipeline_nv_props) {
+        rt_pipeline_nv_props->shaderGroupHandleSize = 32;
+        rt_pipeline_nv_props->shaderGroupBaseAlignment = 64;
+    }
+
+    auto *texel_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceTexelBufferAlignmentProperties>(pProperties->pNext);
+    if (texel_buffer_props) {
+        texel_buffer_props->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        texel_buffer_props->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE;
+        texel_buffer_props->storageTexelBufferOffsetAlignmentBytes = 16;
+        texel_buffer_props->uniformTexelBufferOffsetAlignmentBytes = 16;
+    }
+
+    auto *descriptor_buffer_props = lvl_find_mod_in_chain<VkPhysicalDeviceDescriptorBufferPropertiesEXT>(pProperties->pNext);
+    if (descriptor_buffer_props) {
+        descriptor_buffer_props->combinedImageSamplerDescriptorSingleArray = VK_TRUE;
+        descriptor_buffer_props->bufferlessPushDescriptors = VK_TRUE;
+        descriptor_buffer_props->allowSamplerImageViewPostSubmitCreation = VK_TRUE;
+        descriptor_buffer_props->descriptorBufferOffsetAlignment = 4;
+    }
+
+    auto *mesh_shader_props = lvl_find_mod_in_chain<VkPhysicalDeviceMeshShaderPropertiesEXT>(pProperties->pNext);
+    if (mesh_shader_props) {
+        mesh_shader_props->meshOutputPerVertexGranularity = 32;
+        mesh_shader_props->meshOutputPerPrimitiveGranularity = 32;
+        mesh_shader_props->prefersLocalInvocationVertexOutput = VK_TRUE;
+        mesh_shader_props->prefersLocalInvocationPrimitiveOutput = VK_TRUE;
+        mesh_shader_props->prefersCompactVertexOutput = VK_TRUE;
+        mesh_shader_props->prefersCompactPrimitiveOutput = VK_TRUE;
+    }
+
+    auto *fragment_density_map2_props = lvl_find_mod_in_chain<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>(pProperties->pNext);
+    if (fragment_density_map2_props) {
+        fragment_density_map2_props->subsampledLoads = VK_FALSE;
+        fragment_density_map2_props->subsampledCoarseReconstructionEarlyAccess = VK_FALSE;
+        fragment_density_map2_props->maxSubsampledArrayLayers = 2;
+        fragment_density_map2_props->maxDescriptorSetSubsampledSamplers = 1;
+    }
+
+    auto *maintenance3_props = lvl_find_mod_in_chain<VkPhysicalDeviceMaintenance3Properties>(pProperties->pNext);
+    if (maintenance3_props) {
+        maintenance3_props->maxMemoryAllocationSize = 1073741824;
+        maintenance3_props->maxPerSetDescriptors = 1024;
+    }
+
+    const uint32_t num_copy_layouts = 5;
+    const VkImageLayout HostCopyLayouts[]{
+       VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+       VK_IMAGE_LAYOUT_GENERAL,
+       VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
+       VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,
+       VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
+    };
+
+    auto *host_image_copy_props = lvl_find_mod_in_chain<VkPhysicalDeviceHostImageCopyPropertiesEXT>(pProperties->pNext);
+    if (host_image_copy_props){
+        if (host_image_copy_props->pCopyDstLayouts == nullptr) host_image_copy_props->copyDstLayoutCount = num_copy_layouts;
+        else {
+            uint32_t num_layouts = (std::min)(host_image_copy_props->copyDstLayoutCount, num_copy_layouts);
+            for (uint32_t i = 0; i < num_layouts; i++) {
+                host_image_copy_props->pCopyDstLayouts[i] = HostCopyLayouts[i];
+            }
+        }
+        if (host_image_copy_props->pCopySrcLayouts == nullptr) host_image_copy_props->copySrcLayoutCount = num_copy_layouts;
+        else {
+            uint32_t num_layouts = (std::min)(host_image_copy_props->copySrcLayoutCount, num_copy_layouts);
+             for (uint32_t i = 0; i < num_layouts; i++) {
+                host_image_copy_props->pCopySrcLayouts[i] = HostCopyLayouts[i];
+            }
+        }
+    }
+
+    auto *driver_properties = lvl_find_mod_in_chain<VkPhysicalDeviceDriverProperties>(pProperties->pNext);
+    if (driver_properties) {
+        std::strncpy(driver_properties->driverName, "Vulkan Mock Device", VK_MAX_DRIVER_NAME_SIZE);
+#if defined(GIT_BRANCH_NAME) && defined(GIT_TAG_INFO)
+        std::strncpy(driver_properties->driverInfo, "Branch: " GIT_BRANCH_NAME " Tag Info: " GIT_TAG_INFO, VK_MAX_DRIVER_INFO_SIZE);
+#else
+        std::strncpy(driver_properties->driverInfo, "Branch: --unknown-- Tag Info: --unknown--", VK_MAX_DRIVER_INFO_SIZE);
+#endif
+    }
+
+    auto *layered_properties = lvl_find_mod_in_chain<VkPhysicalDeviceLayeredApiPropertiesListKHR>(pProperties->pNext);
+    if (layered_properties) {
+        layered_properties->layeredApiCount = 1;
+        if (layered_properties->pLayeredApis) {
+            layered_properties->pLayeredApis[0] = VkPhysicalDeviceLayeredApiPropertiesKHR{
+                VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR,
+                nullptr,
+                0xba5eba11,
+                0xf005ba11,
+                VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR
+            };
+            std::strncpy(layered_properties->pLayeredApis[0].deviceName, "Fake Driver", VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
+        }
+    }
+''',
+'vkGetPhysicalDeviceExternalSemaphoreProperties':'''
+    // Hard code support for all handle types and features
+    pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F;
+    pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F;
+    pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3;
+''',
+'vkGetPhysicalDeviceExternalSemaphorePropertiesKHR':'''
+    GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+''',
+'vkGetPhysicalDeviceExternalFenceProperties':'''
+    // Hard-code support for all handle types and features
+    pExternalFenceProperties->exportFromImportedHandleTypes = 0xF;
+    pExternalFenceProperties->compatibleHandleTypes = 0xF;
+    pExternalFenceProperties->externalFenceFeatures = 0x3;
+''',
+'vkGetPhysicalDeviceExternalFencePropertiesKHR':'''
+    GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+''',
+'vkGetPhysicalDeviceExternalBufferProperties':'''
+    constexpr VkExternalMemoryHandleTypeFlags supported_flags = 0x1FF;
+    if (pExternalBufferInfo->handleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) {
+        // Can't have dedicated memory with AHB
+        pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
+        pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = pExternalBufferInfo->handleType;
+        pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType;
+    } else if (pExternalBufferInfo->handleType & supported_flags) {
+        pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0x7;
+        pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = supported_flags;
+        pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = supported_flags;
+    } else {
+        pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0;
+        pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0;
+        // According to spec, handle type is always compatible with itself. Even if export/import
+        // not supported, it's important to properly implement self-compatibility property since
+        // application's control flow can rely on this.
+        pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType;
+    }
+''',
+'vkGetPhysicalDeviceExternalBufferPropertiesKHR':'''
+    GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+''',
+'vkGetBufferMemoryRequirements': '''
+    // TODO: Just hard-coding reqs for now
+    pMemoryRequirements->size = 4096;
+    pMemoryRequirements->alignment = 1;
+    pMemoryRequirements->memoryTypeBits = 0xFFFF;
+    // Return a better size based on the buffer size from the create info.
+    unique_lock_t lock(global_lock);
+    auto d_iter = buffer_map.find(device);
+    if (d_iter != buffer_map.end()) {
+        auto iter = d_iter->second.find(buffer);
+        if (iter != d_iter->second.end()) {
+            pMemoryRequirements->size = ((iter->second.size + 4095) / 4096) * 4096;
+        }
+    }
+''',
+'vkGetBufferMemoryRequirements2KHR': '''
+    GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements);
+''',
+'vkGetDeviceBufferMemoryRequirements': '''
+    // TODO: Just hard-coding reqs for now
+    pMemoryRequirements->memoryRequirements.alignment = 1;
+    pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF;
+
+    // Return a size based on the buffer size from the create info.
+    pMemoryRequirements->memoryRequirements.size = ((pInfo->pCreateInfo->size + 4095) / 4096) * 4096;
+''',
+'vkGetDeviceBufferMemoryRequirementsKHR': '''
+    GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
+''',
+'vkGetImageMemoryRequirements': '''
+    pMemoryRequirements->size = 0;
+    pMemoryRequirements->alignment = 1;
+
+    unique_lock_t lock(global_lock);
+    auto d_iter = image_memory_size_map.find(device);
+    if(d_iter != image_memory_size_map.end()){
+        auto iter = d_iter->second.find(image);
+        if (iter != d_iter->second.end()) {
+            pMemoryRequirements->size = iter->second;
+        }
+    }
+    // Here we hard-code that the memory type at index 3 doesn't support this image.
+    pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3);
+''',
+'vkGetImageMemoryRequirements2KHR': '''
+    GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements);
+''',
+'vkGetDeviceImageMemoryRequirements': '''
+    pMemoryRequirements->memoryRequirements.size = GetImageSizeFromCreateInfo(pInfo->pCreateInfo);
+    pMemoryRequirements->memoryRequirements.alignment = 1;
+    // Here we hard-code that the memory type at index 3 doesn't support this image.
+    pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF & ~(0x1 << 3);
+''',
+'vkGetDeviceImageMemoryRequirementsKHR': '''
+    GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
+''',
+'vkMapMemory': '''
+    unique_lock_t lock(global_lock);
+    if (VK_WHOLE_SIZE == size) {
+        if (allocated_memory_size_map.count(memory) != 0)
+            size = allocated_memory_size_map[memory] - offset;
+        else
+            size = 0x10000;
+    }
+    void* map_addr = malloc((size_t)size);
+    mapped_memory_map[memory].push_back(map_addr);
+    *ppData = map_addr;
+    return VK_SUCCESS;
+''',
+'vkMapMemory2KHR': '''
+    return MapMemory(device, pMemoryMapInfo->memory, pMemoryMapInfo->offset, pMemoryMapInfo->size, pMemoryMapInfo->flags, ppData);
+''',
+'vkUnmapMemory': '''
+    unique_lock_t lock(global_lock);
+    for (auto map_addr : mapped_memory_map[memory]) {
+        free(map_addr);
+    }
+    mapped_memory_map.erase(memory);
+''',
+'vkUnmapMemory2KHR': '''
+    UnmapMemory(device, pMemoryUnmapInfo->memory);
+    return VK_SUCCESS;
+''',
+'vkGetImageSubresourceLayout': '''
+    // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure.
+    *pLayout = VkSubresourceLayout(); // Default constructor zero values.
+''',
+'vkCreateSwapchainKHR': '''
+    unique_lock_t lock(global_lock);
+    *pSwapchain = (VkSwapchainKHR)global_unique_handle++;
+    for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){
+        swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++;
+    }
+    return VK_SUCCESS;
+''',
+'vkDestroySwapchainKHR': '''
+    unique_lock_t lock(global_lock);
+    swapchain_image_map.clear();
+''',
+'vkGetSwapchainImagesKHR': '''
+    if (!pSwapchainImages) {
+        *pSwapchainImageCount = icd_swapchain_image_count;
+    } else {
+        unique_lock_t lock(global_lock);
+        for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){
+            pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i];
+        }
+
+        if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE;
+        else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count;
+    }
+    return VK_SUCCESS;
+''',
+'vkAcquireNextImageKHR': '''
+    *pImageIndex = 0;
+    return VK_SUCCESS;
+''',
+'vkAcquireNextImage2KHR': '''
+    *pImageIndex = 0;
+    return VK_SUCCESS;
+''',
+'vkCreateBuffer': '''
+    unique_lock_t lock(global_lock);
+    *pBuffer = (VkBuffer)global_unique_handle++;
+     buffer_map[device][*pBuffer] = {
+         pCreateInfo->size,
+         current_available_address
+     };
+     current_available_address += pCreateInfo->size;
+     // Always align to next 64-bit pointer
+     const uint64_t alignment = current_available_address % 64;
+     if (alignment != 0) {
+         current_available_address += (64 - alignment);
+     }
+    return VK_SUCCESS;
+''',
+'vkDestroyBuffer': '''
+    unique_lock_t lock(global_lock);
+    buffer_map[device].erase(buffer);
+''',
+'vkCreateImage': '''
+    unique_lock_t lock(global_lock);
+    *pImage = (VkImage)global_unique_handle++;
+    image_memory_size_map[device][*pImage] = GetImageSizeFromCreateInfo(pCreateInfo);
+    return VK_SUCCESS;
+''',
+'vkDestroyImage': '''
+    unique_lock_t lock(global_lock);
+    image_memory_size_map[device].erase(image);
+''',
+'vkEnumeratePhysicalDeviceGroupsKHR': '''
+    if (!pPhysicalDeviceGroupProperties) {
+        *pPhysicalDeviceGroupCount = 1;
+    } else {
+        // arbitrary
+        pPhysicalDeviceGroupProperties->physicalDeviceCount = 1;
+        pPhysicalDeviceGroupProperties->physicalDevices[0] = physical_device_map.at(instance)[0];
+        pPhysicalDeviceGroupProperties->subsetAllocation = VK_FALSE;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceMultisamplePropertiesEXT': '''
+    if (pMultisampleProperties) {
+        // arbitrary
+        pMultisampleProperties->maxSampleLocationGridSize = {32, 32};
+    }
+''',
+'vkGetPhysicalDeviceFragmentShadingRatesKHR': '''
+    if (!pFragmentShadingRates) {
+        *pFragmentShadingRateCount = 1;
+    } else {
+        // arbitrary
+        pFragmentShadingRates->sampleCounts = VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT;
+        pFragmentShadingRates->fragmentSize = {8, 8};
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceCalibrateableTimeDomainsEXT': '''
+    if (!pTimeDomains) {
+        *pTimeDomainCount = 1;
+    } else {
+        // arbitrary
+        *pTimeDomains = VK_TIME_DOMAIN_DEVICE_EXT;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceCalibrateableTimeDomainsKHR': '''
+    if (!pTimeDomains) {
+        *pTimeDomainCount = 1;
+    } else {
+        // arbitrary
+        *pTimeDomains = VK_TIME_DOMAIN_DEVICE_KHR;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetFenceWin32HandleKHR': '''
+    *pHandle = (HANDLE)0x12345678;
+    return VK_SUCCESS;
+''',
+'vkGetFenceFdKHR': '''
+    *pFd = 0x42;
+    return VK_SUCCESS;
+''',
+'vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR': '''
+    if (!pCounters) {
+        *pCounterCount = 3;
+    } else {
+        if (*pCounterCount == 0){
+            return VK_INCOMPLETE;
+        }
+        // arbitrary
+        pCounters[0].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR;
+        pCounters[0].scope = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR;
+        pCounters[0].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR;
+        pCounters[0].uuid[0] = 0x01;
+        if (*pCounterCount == 1){
+            return VK_INCOMPLETE;
+        }
+        pCounters[1].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR;
+        pCounters[1].scope = VK_QUERY_SCOPE_RENDER_PASS_KHR;
+        pCounters[1].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR;
+        pCounters[1].uuid[0] = 0x02;
+        if (*pCounterCount == 2){
+            return VK_INCOMPLETE;
+        }
+        pCounters[2].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR;
+        pCounters[2].scope = VK_QUERY_SCOPE_COMMAND_KHR;
+        pCounters[2].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR;
+        pCounters[2].uuid[0] = 0x03;
+        *pCounterCount = 3;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR': '''
+    if (pNumPasses) {
+        // arbitrary
+        *pNumPasses = 1;
+    }
+''',
+'vkGetShaderModuleIdentifierEXT': '''
+    if (pIdentifier) {
+        // arbitrary
+        pIdentifier->identifierSize = 1;
+        pIdentifier->identifier[0] = 0x01;
+    }
+''',
+'vkGetImageSparseMemoryRequirements': '''
+    if (!pSparseMemoryRequirements) {
+        *pSparseMemoryRequirementCount = 1;
+    } else {
+        // arbitrary
+        pSparseMemoryRequirements->imageMipTailFirstLod = 0;
+        pSparseMemoryRequirements->imageMipTailSize = 8;
+        pSparseMemoryRequirements->imageMipTailOffset = 0;
+        pSparseMemoryRequirements->imageMipTailStride = 4;
+        pSparseMemoryRequirements->formatProperties.imageGranularity = {4, 4, 4};
+        pSparseMemoryRequirements->formatProperties.flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT;
+        // Would need to track the VkImage to know format for better value here
+        pSparseMemoryRequirements->formatProperties.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT;
+    }
+
+''',
+'vkGetImageSparseMemoryRequirements2KHR': '''
+    if (pSparseMemoryRequirementCount && pSparseMemoryRequirements) {
+        GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, &pSparseMemoryRequirements->memoryRequirements);
+    } else {
+        GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, nullptr);
+    }
+''',
+'vkGetBufferDeviceAddress': '''
+    VkDeviceAddress address = 0;
+    auto d_iter = buffer_map.find(device);
+    if (d_iter != buffer_map.end()) {
+        auto iter = d_iter->second.find(pInfo->buffer);
+        if (iter != d_iter->second.end()) {
+            address = iter->second.address;
+        }
+    }
+    return address;
+''',
+'vkGetBufferDeviceAddressKHR': '''
+    return GetBufferDeviceAddress(device, pInfo);
+''',
+'vkGetBufferDeviceAddressEXT': '''
+    return GetBufferDeviceAddress(device, pInfo);
+''',
+'vkGetDescriptorSetLayoutSizeEXT': '''
+    // Need to give something non-zero
+    *pLayoutSizeInBytes = 4;
+''',
+'vkGetAccelerationStructureBuildSizesKHR': '''
+    // arbitrary
+    pSizeInfo->accelerationStructureSize = 4;
+    pSizeInfo->updateScratchSize = 4;
+    pSizeInfo->buildScratchSize = 4;
+''',
+'vkGetAccelerationStructureMemoryRequirementsNV': '''
+    // arbitrary
+    pMemoryRequirements->memoryRequirements.size = 4096;
+    pMemoryRequirements->memoryRequirements.alignment = 1;
+    pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF;
+''',
+'vkGetAccelerationStructureDeviceAddressKHR': '''
+    // arbitrary - need to be aligned to 256 bytes
+    return 0x262144;
+''',
+'vkGetVideoSessionMemoryRequirementsKHR': '''
+    if (!pMemoryRequirements) {
+        *pMemoryRequirementsCount = 1;
+    } else {
+        // arbitrary
+        pMemoryRequirements[0].memoryBindIndex = 0;
+        pMemoryRequirements[0].memoryRequirements.size = 4096;
+        pMemoryRequirements[0].memoryRequirements.alignment = 1;
+        pMemoryRequirements[0].memoryRequirements.memoryTypeBits = 0xFFFF;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR': '''
+    if (!pProperties) {
+        *pPropertyCount = 2;
+    } else {
+        // arbitrary
+        pProperties[0].MSize = 16;
+        pProperties[0].NSize = 16;
+        pProperties[0].KSize = 16;
+        pProperties[0].AType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].BType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].CType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].ResultType = VK_COMPONENT_TYPE_UINT32_KHR;
+        pProperties[0].saturatingAccumulation = VK_FALSE;
+        pProperties[0].scope = VK_SCOPE_SUBGROUP_KHR;
+
+        pProperties[1] = pProperties[0];
+        pProperties[1].scope = VK_SCOPE_DEVICE_KHR;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceVideoCapabilitiesKHR': '''
+    return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR;
+''',
+'vkGetPhysicalDeviceVideoFormatPropertiesKHR': '''
+    return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR;
+''',
+'vkGetDescriptorSetLayoutSupport':'''
+    if (pSupport) {
+        pSupport->supported = VK_TRUE;
+    }
+''',
+'vkGetDescriptorSetLayoutSupportKHR':'''
+    GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+''',
+'vkGetRenderAreaGranularity': '''
+    pGranularity->width = 1;
+    pGranularity->height = 1;
+''',
+'vkGetMemoryFdKHR': '''
+    *pFd = 1;
+    return VK_SUCCESS;
+''',
+'vkGetMemoryHostPointerPropertiesEXT': '''
+    pMemoryHostPointerProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type
+    return VK_SUCCESS;
+''',
+'vkGetAndroidHardwareBufferPropertiesANDROID': '''
+    pProperties->allocationSize = 65536;
+    pProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type
+
+    auto *format_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatPropertiesANDROID>(pProperties->pNext);
+    if (format_prop) {
+        // Likley using this format
+        format_prop->format = VK_FORMAT_R8G8B8A8_UNORM;
+        format_prop->externalFormat = 37;
+    }
+
+    auto *format_resolve_prop = lvl_find_mod_in_chain<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>(pProperties->pNext);
+    if (format_resolve_prop) {
+        format_resolve_prop->colorAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPhysicalDeviceDisplayPropertiesKHR': '''
+    if (!pProperties) {
+        *pPropertyCount = 1;
+    } else {
+        unique_lock_t lock(global_lock);
+        pProperties[0].display = (VkDisplayKHR)global_unique_handle++;
+        display_map[physicalDevice].insert(pProperties[0].display);
+    }
+    return VK_SUCCESS;
+''',
+'vkRegisterDisplayEventEXT': '''
+    unique_lock_t lock(global_lock);
+    *pFence = (VkFence)global_unique_handle++;
+    return VK_SUCCESS;
+''',
+'vkQueueSubmit': '''
+    // Special way to cause DEVICE_LOST
+    // Picked VkExportFenceCreateInfo because needed some struct that wouldn't get cleared by validation Safe Struct
+    // ... TODO - It would be MUCH nicer to have a layer or other setting control when this occured
+    // For now this is used to allow Validation Layers test reacting to device losts
+    if (submitCount > 0 && pSubmits) {
+        auto pNext = reinterpret_cast<const VkBaseInStructure *>(pSubmits[0].pNext);
+        if (pNext && pNext->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO && pNext->pNext == nullptr) {
+            return VK_ERROR_DEVICE_LOST;
+        }
+    }
+    return VK_SUCCESS;
+''',
+'vkGetMemoryWin32HandlePropertiesKHR': '''
+    pMemoryWin32HandleProperties->memoryTypeBits = 0xFFFF;
+    return VK_SUCCESS;
+''',
+'vkCreatePipelineBinariesKHR': '''
+    unique_lock_t lock(global_lock);
+    if (pBinaries->pPipelineBinaries != nullptr)
+    {
+        for (uint32_t i = 0; i < pBinaries->pipelineBinaryCount; ++i) {
+            pBinaries->pPipelineBinaries[i] = (VkPipelineBinaryKHR)global_unique_handle++;
+        }
+    }
+    else
+    {
+       // In this case, we need to return a return count, let's set it to 3
+       pBinaries->pipelineBinaryCount = 3;
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPipelineKeyKHR': '''
+    if (pPipelineKey != nullptr)
+    {
+        pPipelineKey->keySize = 16;
+        std::memset(pPipelineKey->key, 0x12, pPipelineKey->keySize);
+    }
+    return VK_SUCCESS;
+''',
+'vkGetPipelineBinaryDataKHR': '''
+    static uint32_t fake_size = 64;
+    if (pPipelineBinaryDataSize != nullptr)
+    {
+        if (pPipelineBinaryData == nullptr)
+        {
+            *pPipelineBinaryDataSize = fake_size;
+        }
+        else
+        {
+            std::memset(pPipelineBinaryData, 0xABCD, fake_size);
+        }
+    }
+    return VK_SUCCESS;
+'''
+}
+
+# MockICDOutputGenerator
+# Generates a mock vulkan ICD.
+#  This is intended to be a minimal replacement for a vulkan device in order
+#  to enable testing of Vulkan applications and layers
+#
+class MockICDOutputGenerator(BaseGenerator):
+    def __init__(self):
+        BaseGenerator.__init__(self)
+
+        # Ignore extensions that ICDs should not implement or are not safe to report
+        self.ignore_exts = ['VK_EXT_validation_cache', 'VK_KHR_portability_subset']
+
+        # Dispatchable handles
+        self.dispatchable_handles = ['VkInstance','VkPhysicalDevice', 'VkDevice', 'VkCommandBuffer', 'VkQueue']
+
+    def generate_function_declarations(self, out):
+
+        out.append('#include <stdint.h>\n')
+        out.append('#include <cstring>\n')
+        out.append('#include <string>\n')
+        out.append('#include <unordered_map>\n')
+        out.append('#include <vulkan/vulkan.h>\n')
+        out.append('\n')
+        out.append('namespace vkmock {\n')
+        out.append('// Map of instance extension name to version\n')
+        out.append('static const std::unordered_map<std::string, uint32_t> instance_extension_map = {\n')
+        for ext in [x for x in self.vk.extensions.values() if x.instance and x.name not in self.ignore_exts]:
+            if ext.protect:
+                out.append(f'#ifdef {ext.protect}\n')
+            out.append(f'    {{"{ext.name}", {ext.specVersion}}},\n')
+            if ext.protect:
+                out.append('#endif\n')
+        out.append('};\n')
+        out.append('// Map of device extension name to version\n')
+        out.append('static const std::unordered_map<std::string, uint32_t> device_extension_map = {\n')
+        for ext in [x for x in self.vk.extensions.values() if x.device and x.name not in self.ignore_exts]:
+            if ext.protect:
+                out.append(f'#ifdef {ext.protect}\n')
+            out.append(f'    {{"{ext.name}", {ext.specVersion}}},\n')
+            if ext.protect:
+                out.append('#endif\n')
+        out.append('};\n')
+
+        current_protect = None
+        for name, cmd in self.vk.commands.items():
+            prepend_newline = '\n'
+            if cmd.protect != current_protect:
+                if current_protect is not None:
+                    out.append(f'#endif /* {current_protect} */\n')
+                    prepend_newline = ''
+                if current_protect is not None and cmd.protect is not None:
+                    out.append('\n')
+                if cmd.protect is not None:
+                    out.append(f'#ifdef {cmd.protect}\n')
+                current_protect = cmd.protect
+            out.append(f'{prepend_newline}static {cmd.cPrototype.replace(name, name[2:])}\n')
+        if current_protect is not None:
+            out.append('#endif\n')
+
+            # record intercepted procedures
+        out.append('// Map of all APIs to be intercepted by this layer\n')
+        out.append('static const std::unordered_map<std::string, void*> name_to_funcptr_map = {\n')
+        for name, cmd in self.vk.commands.items():
+            if cmd.protect:
+                out.append(f'#ifdef {cmd.protect}\n')
+            out.append(f'    {{"{name}", (void*){name[2:]}}},\n')
+            if cmd.protect:
+                out.append('#endif\n')
+        out.append('};\n')
+
+    def generate_function_definitions(self, out):
+        out.append('#include "mock_icd.h"\n')
+        out.append('#include "function_declarations.h"\n')
+        out.append('namespace vkmock {\n')
+
+        manual_functions = [
+            # Include functions here to be intercepted w/ manually implemented function bodies
+            'vkGetDeviceProcAddr',
+            'vkGetInstanceProcAddr',
+            'vkCreateDevice',
+            'vkDestroyDevice',
+            'vkCreateInstance',
+            'vkDestroyInstance',
+            'vkFreeCommandBuffers',
+            'vkAllocateCommandBuffers',
+            'vkDestroyCommandPool',
+            #'vkCreateDebugReportCallbackEXT',
+            #'vkDestroyDebugReportCallbackEXT',
+            'vkEnumerateInstanceLayerProperties',
+            'vkEnumerateInstanceVersion',
+            'vkEnumerateInstanceExtensionProperties',
+            'vkEnumerateDeviceLayerProperties',
+            'vkEnumerateDeviceExtensionProperties',
+            'vkGetPipelineKeyKHR',
+            'vkGetPipelineBinaryDataKHR',
+        ]
+
+        current_protect = None
+        for name, cmd in self.vk.commands.items():
+            if cmd.protect != current_protect:
+                if current_protect is not None:
+                    out.append(f'#endif /* {current_protect} */\n')
+                if current_protect is not None and cmd.protect is not None:
+                    out.append('\n')
+                if cmd.protect is not None:
+                    out.append(f'#ifdef {cmd.protect}\n')
+                current_protect = cmd.protect
+
+            if name in manual_functions:
+                if name not in CUSTOM_C_INTERCEPTS:
+                    out.append(f'static {cmd.cPrototype.replace(name, name[2:])}\n')
+                    out.append('// TODO: Implement custom intercept body\n')
+                else:
+                    out.append(f'static {cmd.cPrototype[:-1].replace(name, name[2:])}\n')
+                    out.append(f'{{{CUSTOM_C_INTERCEPTS[name]}}}\n')
+                continue
+
+            out.append(f'static {cmd.cPrototype[:-1].replace(name, name[2:])}\n')
+            if name in CUSTOM_C_INTERCEPTS:
+                out.append(f'{{{CUSTOM_C_INTERCEPTS[name]}}}\n')
+                continue
+
+            # if the name w/ KHR postfix is in the CUSTOM_C_INTERCEPTS
+            # Call the KHR custom version instead of generating separate code
+            khr_name = name + "KHR"
+            if khr_name in CUSTOM_C_INTERCEPTS:
+                return_string = ''
+                if cmd.returnType != 'void':
+                    return_string = 'return '
+
+                param_names = []
+                for param in cmd.params:
+                    param_names.append(param.name)
+                out.append(f'{{\n    {return_string}{khr_name[2:]}({", ".join(param_names)});\n}}\n')
+                continue
+            out.append('{\n')
+
+            # GET THE TYPE OF FUNCTION
+            if any(name.startswith(ftxt) for ftxt in ('vkCreate', 'vkAllocate')):
+                # Get last param
+                last_param = cmd.params[-1]
+                lp_txt = last_param.name
+                lp_len = None
+                if last_param.length is not None:
+                    lp_len = last_param.length
+                    lp_len = lp_len.replace('::', '->')
+                lp_type = last_param.type
+                handle_type = 'dispatchable'
+                allocator_txt = 'CreateDispObjHandle()'
+                if lp_type not in self.dispatchable_handles:
+                    handle_type = 'non-' + handle_type
+                    allocator_txt = 'global_unique_handle++'
+                # Need to lock in both cases
+                out.append('    unique_lock_t lock(global_lock);\n')
+                if lp_len is not None:
+                    #print("%s last params (%s) has len %s" % (handle_type, lp_txt, lp_len))
+                    out.append(f'    for (uint32_t i = 0; i < {lp_len}; ++i) {{\n')
+                    out.append(f'        {lp_txt}[i] = ({lp_type}){allocator_txt};\n')
+                    out.append('    }\n')
+                else:
+                    #print("Single %s last param is '%s' w/ type '%s'" % (handle_type, lp_txt, lp_type))
+                    if 'AllocateMemory' in name:
+                        # Store allocation size in case it's mapped
+                        out.append('    allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize;\n')
+                    out.append(f'    *{lp_txt} = ({lp_type}){allocator_txt};\n')
+            elif True in [ftxt in name for ftxt in ['Destroy', 'Free']]:
+                out.append('//Destroy object\n')
+                if 'FreeMemory' in name:
+                    # If the memory is mapped, unmap it
+                    out.append('    UnmapMemory(device, memory);\n')
+                    # Remove from allocation map
+                    out.append('    unique_lock_t lock(global_lock);\n')
+                    out.append('    allocated_memory_size_map.erase(memory);\n')
+            else:
+                out.append('//Not a CREATE or DESTROY function\n')
+
+            # Return result variable, if any.
+            if cmd.returnType != 'void':
+                if name == 'vkGetEventStatus':
+                    out.append('    return VK_EVENT_SET;\n')
+                else:
+                    out.append('    return VK_SUCCESS;\n')
+            out.append('}\n')
+        if current_protect is not None:
+            out.append('#endif\n')
+
+    def generate(self):
+        out = []
+        out.append('''/*
+** Copyright (c) 2015-2025 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+#pragma once
+''')
+
+        if self.filename == "function_declarations.h":
+            self.generate_function_declarations(out)
+        else:
+            self.generate_function_definitions(out)
+
+        out.append('\n')
+        out.append('} // namespace vkmock\n')
+        out.append('\n')
+        self.write(''.join(out))
diff --git a/tools/Vulkan-Tools/scripts/generators/vulkan_tools_helper_file_generator.py b/tools/Vulkan-Tools/scripts/generators/vulkan_tools_helper_file_generator.py
new file mode 100644
index 00000000..baf3e816
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/generators/vulkan_tools_helper_file_generator.py
@@ -0,0 +1,163 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2021 The Khronos Group Inc.
+# Copyright (c) 2015-2021 Valve Corporation
+# Copyright (c) 2015-2021 LunarG, Inc.
+# Copyright (c) 2015-2021 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Mark Lobodzinski <mark@lunarg.com>
+# Author: Tobin Ehlis <tobine@google.com>
+# Author: John Zulauf <jzulauf@lunarg.com>
+
+from base_generator import BaseGenerator
+
+# HelperFileOutputGenerator - subclass of OutputGenerator. Outputs Vulkan helper files
+class HelperFileOutputGenerator(BaseGenerator):
+    def __init__(self):
+        BaseGenerator.__init__(self)
+
+
+    def generate(self):
+        out = []
+
+        # File Comment
+        out.append('// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n')
+        out.append('// See vulkan_tools_helper_file_generator.py for modifications\n')
+
+        # Copyright Notice
+        out.append('''
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
+ * Copyright (c) 2015-2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Chris Forbes <chrisforbes@google.com>
+ * Author: John Zulauf<jzulauf@lunarg.com>
+ *
+ ****************************************************************************/
+''')
+
+        # Generate header
+        out.append('''
+#pragma once
+#include <vulkan/vulkan.h>
+
+// These empty generic templates are specialized for each type with sType
+// members and for each sType -- providing a two way map between structure
+// types and sTypes
+
+template <VkStructureType id> struct LvlSTypeMap {};
+template <typename T> struct LvlTypeMap {};
+
+''')
+
+        # Generate the specializations for each type and stype
+        for struct in self.vk.structs.values():
+            if struct.sType is None:
+                continue
+
+            if struct.protect is not None:
+                out.append(f'#ifdef {struct.protect}\n')
+
+            out.append(f'// Map type {struct.name} to id {struct.sType}\n')
+            out.append(f'template <> struct LvlTypeMap<{struct.name}> {{\n')
+            out.append(f'    static const VkStructureType kSType = {struct.sType};\n')
+            out.append('};\n\n')
+
+
+            out.append(f'template <> struct LvlSTypeMap<{struct.sType}> {{\n')
+            out.append(f'    typedef {struct.name} Type;\n')
+            out.append('};\n\n')
+
+            if struct.protect is not None:
+                out.append(f'#endif // {struct.protect}\n')
+
+ # Define the utilities (here so any renaming stays consistent), if this grows large, refactor to a fixed .h file
+
+        out.append('''// Header "base class" for pNext chain traversal
+struct LvlGenericHeader {
+   VkStructureType sType;
+   const LvlGenericHeader *pNext;
+};
+struct LvlGenericModHeader {
+   VkStructureType sType;
+   LvlGenericModHeader *pNext;
+};
+
+// Find an entry of the given type in the pNext chain
+template <typename T> const T *lvl_find_in_chain(const void *next) {
+    const LvlGenericHeader *current = reinterpret_cast<const LvlGenericHeader *>(next);
+    const T *found = nullptr;
+    while (current) {
+        if (LvlTypeMap<T>::kSType == current->sType) {
+            found = reinterpret_cast<const T*>(current);
+            current = nullptr;
+        } else {
+            current = current->pNext;
+        }
+    }
+    return found;
+}
+// Find an entry of the given type in the pNext chain
+template <typename T> T *lvl_find_mod_in_chain(void *next) {
+    LvlGenericModHeader *current = reinterpret_cast<LvlGenericModHeader *>(next);
+    T *found = nullptr;
+    while (current) {
+        if (LvlTypeMap<T>::kSType == current->sType) {
+            found = reinterpret_cast<T*>(current);
+            current = nullptr;
+        } else {
+            current = current->pNext;
+        }
+    }
+    return found;
+}
+
+// Init the header of an sType struct with pNext
+template <typename T> T lvl_init_struct(void *p_next) {
+    T out = {};
+    out.sType = LvlTypeMap<T>::kSType;
+    out.pNext = p_next;
+    return out;
+}
+
+// Init the header of an sType struct
+template <typename T> T lvl_init_struct() {
+    T out = {};
+    out.sType = LvlTypeMap<T>::kSType;
+    return out;
+}
+''')
+
+        self.write(''.join(out))
+
diff --git a/tools/Vulkan-Tools/scripts/generators/vulkaninfo_generator.py b/tools/Vulkan-Tools/scripts/generators/vulkaninfo_generator.py
new file mode 100644
index 00000000..472459ac
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/generators/vulkaninfo_generator.py
@@ -0,0 +1,1165 @@
+#!/usr/bin/python3
+#
+# Copyright (c) 2019-2026 Valve Corporation
+# Copyright (c) 2019-2026 LunarG, Inc.
+# Copyright (c) 2019-2022 Google Inc.
+# Copyright (c) 2023-2024 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Author: Charles Giessen <charles@lunarg.com>
+
+from base_generator import BaseGenerator
+
+from collections import OrderedDict
+
+LICENSE_HEADER = '''
+/*
+ * Copyright (c) 2019-2026 The Khronos Group Inc.
+ * Copyright (c) 2019-2026 Valve Corporation
+ * Copyright (c) 2019-2026 LunarG, Inc.
+ * Copyright (c) 2023-2024 RasterGrid Kft.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Author: Charles Giessen <charles@lunarg.com>
+ *
+ */
+
+/*
+ * This file is generated from the Khronos Vulkan XML API Registry.
+ */
+'''
+
+CUSTOM_FORMATTERS = r'''
+template <typename T>
+std::string to_hex_str(const T i) {
+    std::stringstream stream;
+    stream << "0x" << std::setfill('0') << std::setw(sizeof(T)) << std::hex << i;
+    return stream.str();
+}
+
+template <typename T>
+std::string to_hex_str(Printer &p, const T i) {
+    if (p.Type() == OutputType::json)
+        return std::to_string(i);
+    else if (p.Type() == OutputType::vkconfig_output)
+        return std::string("\"") + to_hex_str(i) + std::string("\"");
+    else
+        return to_hex_str(i);
+}
+
+'''
+
+
+# used in the .cpp code
+STRUCTURES_TO_GEN = ['VkExtent3D', 'VkExtent2D', 'VkPhysicalDeviceLimits', 'VkPhysicalDeviceFeatures', 'VkPhysicalDeviceSparseProperties',
+                     'VkSurfaceCapabilitiesKHR', 'VkSurfaceFormatKHR', 'VkLayerProperties', 'VkPhysicalDeviceToolProperties', 'VkFormatProperties',
+                     'VkSurfacePresentScalingCapabilitiesKHR', 'VkSurfacePresentModeCompatibilityKHR', 'VkPhysicalDeviceHostImageCopyProperties',
+                     'VkVideoProfileInfoKHR', 'VkVideoCapabilitiesKHR', 'VkVideoFormatPropertiesKHR', 'VkCooperativeMatrixPropertiesKHR',
+                     'VkPhysicalDeviceFragmentShadingRateKHR', 'VkMultisamplePropertiesEXT',
+                     'VkDisplayPropertiesKHR', 'VkDisplayPlanePropertiesKHR', 'VkDisplayPlaneCapabilitiesKHR', 'VkDisplayModePropertiesKHR',
+                     'VkDisplayModeParametersKHR']
+
+ENUMS_TO_GEN = ['VkResult', 'VkFormat', 'VkPresentModeKHR',
+                'VkPhysicalDeviceType', 'VkImageTiling', 'VkTimeDomainKHR']
+FLAGS_TO_GEN = ['VkSurfaceTransformFlagsKHR', 'VkCompositeAlphaFlagsKHR', 'VkSurfaceCounterFlagsEXT', 'VkQueueFlags',
+                'VkDeviceGroupPresentModeFlagsKHR', 'VkFormatFeatureFlags', 'VkFormatFeatureFlags2', 'VkMemoryPropertyFlags', 'VkMemoryHeapFlags']
+FLAG_STRINGS_TO_GEN = ['VkQueueFlags']
+
+STRUCT_SHORT_VERSIONS_TO_GEN = ['VkExtent3D', 'VkExtent2D']
+
+STRUCT_COMPARISONS_TO_GEN = ['VkSurfaceFormatKHR', 'VkSurfaceFormat2KHR', 'VkSurfaceCapabilitiesKHR',
+                             'VkSurfaceCapabilities2KHR', 'VkSurfaceCapabilities2EXT']
+# don't generate these structures
+STRUCT_BLACKLIST = ['VkVideoProfileListInfoKHR', 'VkDrmFormatModifierPropertiesListEXT', 'VkDrmFormatModifierPropertiesEXT', 'VkDrmFormatModifierPropertiesList2EXT']
+# These structures are only used in version 1.1, otherwise they are included in the promoted structs
+STRUCT_1_1_LIST = ['VkPhysicalDeviceProtectedMemoryFeatures', 'VkPhysicalDeviceShaderDrawParametersFeatures', 'VkPhysicalDeviceSubgroupProperties', 'VkPhysicalDeviceProtectedMemoryProperties']
+
+# generate these structures such that they only print when not in json mode (as json wants them separate)
+PORTABILITY_STRUCTS = ['VkPhysicalDevicePortabilitySubsetFeaturesKHR', 'VkPhysicalDevicePortabilitySubsetPropertiesKHR']
+
+# iostream or custom outputter handles these types
+PREDEFINED_TYPES = ['char', 'VkBool32', 'uint32_t', 'uint8_t', 'int32_t',
+                    'float', 'uint64_t', 'size_t', 'VkDeviceSize', 'int64_t']
+
+NAMES_TO_IGNORE = ['sType', 'pNext', 'displayMode', 'display', 'currentDisplay']
+
+EXTENSION_TYPE_INSTANCE = 'instance'
+EXTENSION_TYPE_DEVICE = 'device'
+EXTENSION_TYPE_BOTH = 'both'
+
+# Types that need pNext Chains built. 'extends' is the xml tag used in the structextends member. 'type' can be device, instance, or both
+EXTENSION_CATEGORIES = OrderedDict((
+    ('phys_device_props2',
+        {'extends': 'VkPhysicalDeviceProperties2',
+         'type': EXTENSION_TYPE_BOTH,
+         'print_iterator': True,
+         'can_show_promoted_structs': True,
+         'ignore_vendor_exclusion': False}),
+    ('phys_device_mem_props2',
+        {'extends': 'VkPhysicalDeviceMemoryProperties2',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': False,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': False}),
+    ('phys_device_features2',
+        {'extends': 'VkPhysicalDeviceFeatures2',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': True,
+         'ignore_vendor_exclusion': False}),
+    ('surface_capabilities2',
+        {'extends': 'VkSurfaceCapabilities2KHR',
+         'type': EXTENSION_TYPE_BOTH,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': False,
+         'exclude': ['VkSurfacePresentScalingCapabilitiesKHR', 'VkSurfacePresentModeCompatibilityKHR']}),
+    ('format_properties2',
+        {'extends': 'VkFormatProperties2',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': False}),
+    ('queue_properties2',
+        {'extends': 'VkQueueFamilyProperties2',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': False}),
+    ('video_profile_info',
+        {'extends': 'VkVideoProfileInfoKHR',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': True}),
+    ('video_capabilities',
+        {'extends': 'VkVideoCapabilitiesKHR',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': True,}),
+    ('video_format_properties',
+        {'extends': 'VkVideoFormatPropertiesKHR',
+         'type': EXTENSION_TYPE_DEVICE,
+         'print_iterator': True,
+         'can_show_promoted_structs': False,
+         'ignore_vendor_exclusion': True})
+                                   ))
+class VulkanInfoGenerator(BaseGenerator):
+    def __init__(self):
+        BaseGenerator.__init__(self)
+        self.format_ranges = []
+
+    def generate(self):
+        self.findFormatRanges()
+
+        # gather the types that are needed to generate
+        types_to_gen = set()
+        types_to_gen.update(ENUMS_TO_GEN)
+        types_to_gen.update(FLAGS_TO_GEN)
+        types_to_gen.update(STRUCTURES_TO_GEN)
+
+        extension_types = {}
+        for key, ext_info in EXTENSION_CATEGORIES.items():
+            extension_types[key] = []
+
+            for extended_struct in self.vk.structs[ext_info.get('extends')].extendedBy:
+                if ext_info.get('exclude') is not None and extended_struct in ext_info.get('exclude'):
+                    continue
+                elif ext_info.get('ignore_vendor_exclusion'):
+                    extension_types[key].append(extended_struct)
+                    continue
+                vendor_tags = []
+                for extension in self.vk.structs[extended_struct].extensions:
+                    vendor_tags.append(extension.split('_')[1])
+                if len(vendor_tags) == 0 or 'KHR' in vendor_tags or 'EXT' in vendor_tags:
+                    extension_types[key].append(extended_struct)
+            extension_types[key] = sorted(extension_types[key])
+            types_to_gen.update(extension_types[key])
+
+        # find all the types that need
+        types_to_gen.update(self.findAllTypesToGen(types_to_gen))
+
+        types_to_gen = sorted(types_to_gen)
+
+        comparison_types_to_gen = set()
+        comparison_types_to_gen.update(STRUCT_COMPARISONS_TO_GEN)
+        comparison_types_to_gen.update(self.findAllTypesToGen(comparison_types_to_gen))
+        comparison_types_to_gen = sorted(comparison_types_to_gen)
+
+
+        # print the types gathered
+        out = []
+        out.append(LICENSE_HEADER + '\n')
+        out.append('#include "vulkaninfo.h"\n')
+        out.append('#include "outputprinter.h"\n')
+        out.append(CUSTOM_FORMATTERS)
+
+        out.extend(self.genVideoEnums())
+
+        for enum in (e for e in types_to_gen if e in self.vk.enums):
+            out.extend(self.PrintEnumToString(self.vk.enums[enum]))
+            out.extend(self.PrintEnum(self.vk.enums[enum]))
+
+        # Need to go through all flags to find if they or their associated bitmask needs printing
+        # This is because both bitmask and flag types are generated in PrintBitMask
+        for name in (x for x in sorted(self.vk.flags.keys()) if x in types_to_gen or self.vk.flags[x].bitmaskName in types_to_gen):
+            bitmask = self.vk.bitmasks[self.vk.flags[name].bitmaskName]
+
+            out.extend(self.PrintBitMask(bitmask, bitmask.flagName))
+
+            if bitmask.flagName in FLAG_STRINGS_TO_GEN:
+                out.extend(self.PrintBitMaskToString(bitmask, bitmask.flagName))
+        # make sure dump functions for nested structures are declared before use
+        for s in (x for x in types_to_gen if x in self.vk.structs and x not in STRUCT_BLACKLIST):
+            out.extend(self.PrintStructure(self.vk.structs[s], True))
+        for s in (x for x in types_to_gen if x in self.vk.structs and x not in STRUCT_BLACKLIST):
+            out.extend(self.PrintStructure(self.vk.structs[s], False))
+
+        for key, value in EXTENSION_CATEGORIES.items():
+            out.extend(self.PrintChainStruct(key, extension_types[key], value))
+
+        for s in (x for x in comparison_types_to_gen if x in self.vk.structs):
+            out.extend(self.PrintStructComparisonForwardDecl(self.vk.structs[s]))
+        for s in (x for x in comparison_types_to_gen if x in self.vk.structs):
+            out.extend(self.PrintStructComparison(self.vk.structs[s]))
+        for s in (x for x in types_to_gen if x in self.vk.structs and x in STRUCT_SHORT_VERSIONS_TO_GEN):
+            out.extend(self.PrintStructShort(self.vk.structs[s]))
+
+        out.append('auto format_ranges = std::array{\n')
+        for f in self.format_ranges:
+            out.append(f'    FormatRange{{{f.minimum_instance_version}, {self.vk.extensions[f.extensions[0]].nameString if len(f.extensions) > 0 else "nullptr"}, ')
+            out.append(f'static_cast<VkFormat>({f.first_format}), static_cast<VkFormat>({f.last_format})}},\n')
+        out.append('};\n')
+
+        out.extend(self.genVideoProfileUtils())
+
+        self.write(''.join(out))
+
+
+    def genVideoEnums(self):
+        out = []
+        for enum in self.vk.videoStd.enums.values():
+            out.append(f'std::string {enum.name}String({enum.name} value) {{\n')
+            out.append('    switch (value) {\n')
+            for field in enum.fields:
+                # Ignore aliases
+                if field.value is not None:
+                    out.append(f'        case {field.name}: return "{field.name}";\n')
+            out.append(f'        default: return std::string("UNKNOWN_{enum.name}_value") + std::to_string(value);\n')
+            out.append('    }\n}\n')
+            out.append(f'void Dump{enum.name}(Printer &p, std::string name, {enum.name} value) {{\n')
+            out.append(f'    p.PrintKeyString(name, {enum.name}String(value));\n}}\n')
+        return out
+
+
+    # Utility to get the extension / version precondition of a list of type names
+    def GetTypesPrecondition(self, typelist, indent):
+        indent = ' ' * indent
+        out = []
+        extEnables = []
+        for typename in typelist:
+            extEnables.extend(self.vk.structs[typename].extensions)
+
+        version = None
+        for typename in typelist:
+            for v in self.vk.versions.values():
+                if typename in v.name:
+                    if version is not None and (v.major > version.major or (v.major == version.major and v.minor > version.minor)):
+                        version = v
+
+
+        has_version = version is not None
+        has_extNameStr = len(extEnables) > 0
+        if has_version or has_extNameStr:
+            out.append(f'{indent}if (')
+            has_printed_condition = False
+            if has_extNameStr:
+                for ext in extEnables:
+                    if has_printed_condition:
+                        out.append(f'\n{indent} || ')
+                    else:
+                        has_printed_condition = True
+                        if has_version:
+                            out.append('(')
+                    if self.vk.extensions[ext].device:
+                        out.append(f'gpu.CheckPhysicalDeviceExtensionIncluded({self.vk.extensions[ext].nameString})')
+                    else:
+                        assert False, 'Should never get here'
+            if has_version:
+                if has_printed_condition:
+                    out.append(f'\n{indent} || (gpu.api_version >= {version.nameApi})')
+                else:
+                    out.append(f'gpu.api_version >= {version.nameApi}')
+            out.append(') {\n')
+        else:
+            out = f'{indent}{{\n'
+        return out
+
+    # Utility to construct a capability prerequisite condition evaluation expression
+    def GetRequiredCapsCondition(self, structName, memberName, memberRef, value):
+        condition = ''
+        requiredCapStructDef = self.vk.structs[structName]
+        for member in requiredCapStructDef.members:
+            if member.name == memberName:
+                if member.type in self.vk.flags:
+                    # Check that the flags contain all the required values
+                    def genExpressionFromValue(value):
+                        return value if value == "" else f"({memberRef} & {value}) != 0"
+
+                    for char in condition:
+                        if char in ['(', ')', '+', ',']:
+                            condition += genExpressionFromValue(value)
+                            value = ""
+                            if char == '+':
+                                # '+' means AND
+                                condition += ' && '
+                            elif char == ',':
+                                # ',' means OR
+                                condition += ' || '
+                            else:
+                                condition += char
+                        else:
+                            value += char
+                    condition += genExpressionFromValue(value)
+                else:
+                    condition = f'{memberRef} == {value}'
+        if condition == '':
+            return 'true'
+        else:
+            return f'({condition})'
+
+    def genVideoProfileUtils(self):
+        out = []
+
+        # Generate video format properties comparator
+        out.append('''
+bool is_video_format_same(const VkVideoFormatPropertiesKHR &format_a, const VkVideoFormatPropertiesKHR &format_b) {
+    auto a = reinterpret_cast<const VkBaseInStructure*>(&format_a);
+    auto b = reinterpret_cast<const VkBaseInStructure*>(&format_b);
+    bool same = true;
+    while (same && a != nullptr && b != nullptr) {
+        if (a->sType != b->sType) {
+            // Structure type mismatch (extension structures are expected to be chained in the same order)
+            same = false;
+        } else {
+            switch (a->sType) {''')
+
+        if 'VkVideoFormatPropertiesKHR' in self.registry.validextensionstructs:
+            for extstruct in ['VkVideoFormatPropertiesKHR'] + self.registry.validextensionstructs['VkVideoFormatPropertiesKHR']:
+                extstructDef = self.vk.structs[extstruct]
+                out.append(f'''
+                case {extstructDef.sType}:
+                    same = same && memcmp(reinterpret_cast<const char*>(a) + sizeof(VkBaseInStructure),
+                                          reinterpret_cast<const char*>(b) + sizeof(VkBaseInStructure),
+                                          sizeof({extstruct}) - sizeof(VkBaseInStructure)) == 0;
+                    break;''')
+
+        out.append('''
+                default:
+                    // Unexpected structure type
+                    same = false;
+                    break;
+            }
+        }
+        a = a->pNext;
+        b = b->pNext;
+    }
+    return same;
+}
+''')
+
+        # Generate video profile info capture utilities
+        out.append('''
+std::vector<std::unique_ptr<AppVideoProfile>> enumerate_supported_video_profiles(AppGpu &gpu) {
+    std::vector<std::unique_ptr<AppVideoProfile>> result{};
+
+    struct ChromaSubsamplingInfo {
+        VkVideoChromaSubsamplingFlagsKHR value;
+        const char* name;
+    };
+    const std::vector<ChromaSubsamplingInfo> chroma_subsampling_list = {
+        {VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, "4:2:0"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, "4:2:2"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR, "4:4:4"},
+        {VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, "monochrome"}
+    };
+
+    struct BitDepthInfo {
+        VkVideoComponentBitDepthFlagsKHR value;
+        const char* name;
+    };
+    const std::vector<BitDepthInfo> bit_depth_list = {
+        {VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, "8"},
+        {VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, "10"},
+        {VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR, "12"}
+    };
+
+    auto find_caps_struct = [](const VkVideoCapabilitiesKHR &capabilities, VkStructureType stype) -> const VkBaseInStructure* {
+        auto p = reinterpret_cast<const VkBaseInStructure*>(&capabilities);
+        while (p != nullptr) {
+            if (p->sType == stype) {
+                return p;
+            }
+            p = p->pNext;
+        }
+        return nullptr;
+    };
+
+    auto base_format = []
+        (const ChromaSubsamplingInfo &chroma_subsampling, const BitDepthInfo &luma_bit_depth, const BitDepthInfo &chroma_bit_depth) {
+            std::string result{};
+            result += " (";
+            result += chroma_subsampling.name;
+            result += " ";
+            result += luma_bit_depth.name;
+            if (luma_bit_depth.value != chroma_bit_depth.value) {
+                result += ":";
+                result += chroma_bit_depth.name;
+            }
+            result += "-bit)";
+            return result;
+        };
+
+    auto add_profile = [&](
+        const std::string &name,
+        const VkVideoProfileInfoKHR &profile_info,
+        AppVideoProfile::CreateProfileInfoChainCb create_profile_info_chain,
+        AppVideoProfile::CreateCapabilitiesChainCb create_capabilities_chain,
+        const AppVideoProfile::CreateFormatPropertiesChainCbList &create_format_properties_chain_list,
+        AppVideoProfile::InitProfileCb init_profile) {
+            auto profile = std::make_unique<AppVideoProfile>(gpu, gpu.phys_device,
+                                                             name, profile_info,
+                                                             create_profile_info_chain,
+                                                             create_capabilities_chain,
+                                                             create_format_properties_chain_list,
+                                                             init_profile);
+            if (profile->supported) {
+                result.push_back(std::move(profile));
+            }
+        };
+''')
+
+        # Generate individual video profiles from the video codec metadata
+        for videoCodec in self.vk.videoCodecs.values():
+            # Ignore video codec categories
+            if videoCodec.value is None:
+                continue
+
+            out.append('\n')
+            out.extend(self.GetTypesPrecondition(videoCodec.profiles.keys(), 4))
+            out.append(f'{" " * 8}const std::string codec_name = "{videoCodec.name}";\n')
+
+            out.append('''
+        for (auto chroma_subsampling : chroma_subsampling_list) {
+            for (auto luma_bit_depth : bit_depth_list) {
+                for (auto chroma_bit_depth : bit_depth_list) {
+                    if (chroma_subsampling.value == VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR && luma_bit_depth.value != chroma_bit_depth.value) {
+                        // Ignore the chroma bit depth dimension for monochrome
+                        continue;
+                    }
+
+                    std::string profile_base_name = codec_name + base_format(chroma_subsampling, luma_bit_depth, chroma_bit_depth);
+''')
+
+            # Setup video profile info
+            out.append(f'{" " * 20}VkVideoProfileInfoKHR profile_info{{\n')
+            out.append(f'{" " * 20}    VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,\n')
+            out.append(f'{" " * 20}    nullptr,\n')
+            out.append(f'{" " * 20}    {videoCodec.value},\n')
+            out.append(f'{" " * 20}    chroma_subsampling.value,\n')
+            out.append(f'{" " * 20}    luma_bit_depth.value,\n')
+            out.append(f'{" " * 20}    chroma_bit_depth.value\n')
+            out.append(f'{" " * 20}}};\n\n')
+
+            # Setup video profile info chain creation callback
+            out.append(f'{" " * 20}auto create_profile_info_chain = [&](const void **ppnext) -> std::unique_ptr<video_profile_info_chain> {{\n')
+            out.append(f'{" " * 20}    auto profile_info_chain = std::make_unique<video_profile_info_chain>();\n')
+            for profileStruct in videoCodec.profiles:
+                structDef = self.vk.structs[profileStruct]
+                out.append(self.AddGuardHeader(structDef))
+                out.append(f'{" " * 24}if (profile_info_chain != nullptr) {{\n')
+                out.append(f'{" " * 28}profile_info_chain->{profileStruct[2:]}.sType = {structDef.sType};\n')
+                out.append(f'{" " * 28}profile_info_chain->{profileStruct[2:]}.pNext = nullptr;\n')
+                out.append(f'{" " * 28}*ppnext = &profile_info_chain->{profileStruct[2:]};\n')
+                out.append(f'{" " * 28}ppnext = &profile_info_chain->{profileStruct[2:]}.pNext;\n')
+                out.append(f'{" " * 24}}}\n')
+                if structDef.protect:
+                    out.append(f'#else\n{" " * 20}profile_info_chain = nullptr;\n')
+                out.append(self.AddGuardFooter(structDef))
+            out.append(f'{" " * 20}    return profile_info_chain;\n')
+            out.append(f'{" " * 20}}};\n\n')
+
+            # Setup video capabilities chain creation callback
+            out.append(f'{" " * 20}auto create_capabilities_chain = [&](void **ppnext) -> std::unique_ptr<video_capabilities_chain> {{\n')
+            out.append(f'{" " * 20}    auto capabilities_chain = std::make_unique<video_capabilities_chain>();\n')
+            for capabilities in videoCodec.capabilities:
+                structDef = self.vk.structs[capabilities]
+                out.append(self.AddGuardHeader(structDef))
+                out.append(f'{" " * 24}if (capabilities_chain != nullptr) {{\n')
+                out.extend(self.GetTypesPrecondition([capabilities], 28))
+                out.append(f'{" " * 32}capabilities_chain->{capabilities[2:]}.sType = {structDef.sType};\n')
+                out.append(f'{" " * 32}capabilities_chain->{capabilities[2:]}.pNext = nullptr;\n')
+                out.append(f'{" " * 32}*ppnext = &capabilities_chain->{capabilities[2:]};\n')
+                out.append(f'{" " * 32}ppnext = &capabilities_chain->{capabilities[2:]}.pNext;\n')
+                out.append(f'{" " * 28}}}\n')
+                out.append(f'{" " * 24}}}\n')
+                out.append(self.AddGuardFooter(structDef))
+            out.append(f'{" " * 20}    return capabilities_chain;\n')
+            out.append(f'{" " * 20}}};\n\n')
+
+            # Setup video format properties chain creation callbacks
+            out.append(f'{" " * 20}const AppVideoProfile::CreateFormatPropertiesChainCbList create_format_properties_chain_list = {{\n')
+            for format in videoCodec.formats.values():
+                out.append(f'{" " * 24}AppVideoProfile::CreateFormatPropertiesChainCb {{\n')
+                out.append(f'{" " * 28}"{format.name}",\n')
+                out.append(f'{" " * 28}{format.usage.replace("+", " | ")},\n')
+
+                # Callback to check required capabilities
+                out.append(f'{" " * 28}[&](const VkVideoCapabilitiesKHR &capabilities) -> bool {{\n')
+                out.append(f'{" " * 28}    bool supported = true;\n')
+                for requiredCap in format.requiredCaps:
+                    structDef = self.vk.structs[requiredCap.struct]
+                    out.append(self.AddGuardHeader(structDef))
+                    out.extend(self.GetTypesPrecondition([requiredCap.struct], 32))
+                    out.append(f'{" " * 32}    auto caps = reinterpret_cast<const {requiredCap.struct}*>(find_caps_struct(capabilities, {structDef.sType}));\n')
+                    out.append(f'{" " * 32}    if (caps != nullptr) {{\n')
+                    out.append(f'{" " * 32}        supported = supported && {self.GetRequiredCapsCondition(requiredCap.struct, requiredCap.member, f"caps->{requiredCap.member}", requiredCap.value)};\n')
+                    out.append(f'{" " * 32}    }} else {{\n')
+                    out.append(f'{" " * 32}        supported = false;\n')
+                    out.append(f'{" " * 32}    }}\n')
+                    out.append(f'{" " * 32}}} else {{\n')
+                    out.append(f'{" " * 32}    supported = false;\n')
+                    out.append(f'{" " * 32}}}\n')
+                    if structDef.protect:
+                        out.append(f'#else\n{" " * 32}supported = false;\n')
+                    out.append(self.AddGuardFooter(structDef))
+                out.append(f'{" " * 28}    return supported;\n')
+                out.append(f'{" " * 28}}},\n')
+
+                # Callback to create video format properties chain
+                out.append(f'{" " * 28}[&](void **ppnext) -> std::unique_ptr<video_format_properties_chain> {{\n')
+                out.append(f'{" " * 28}    auto format_properties_chain = std::make_unique<video_format_properties_chain>();\n')
+                for formatProps in format.properties:
+                    structDef = self.vk.structs[formatProps]
+                    out.append(self.AddGuardHeader(structDef))
+                    out.append(f'{" " * 32}if (format_properties_chain != nullptr) {{\n')
+                    out.extend(self.GetTypesPrecondition([formatProps], 36))
+                    out.append(f'{" " * 40}format_properties_chain->{formatProps[2:]}.sType = {structDef.sType};\n')
+                    out.append(f'{" " * 40}format_properties_chain->{formatProps[2:]}.pNext = nullptr;\n')
+                    out.append(f'{" " * 40}*ppnext = &format_properties_chain->{formatProps[2:]};\n')
+                    out.append(f'{" " * 40}ppnext = &format_properties_chain->{formatProps[2:]}.pNext;\n')
+                    out.append(f'{" " * 36}}}\n')
+                    out.append(f'{" " * 32}}}\n')
+                    out.append(self.AddGuardFooter(structDef))
+                out.append(f'{" " * 28}    return format_properties_chain;\n')
+                out.append(f'{" " * 28}}},\n')
+
+                out.append(f'{" " * 24}}},\n')
+            out.append(f'{" " * 20}}};\n\n')
+
+            # Permute profiles for each profile struct member value
+            profiles = {'': []}
+            for profileStruct in videoCodec.profiles.values():
+                for profileStructMember in profileStruct.members.values():
+                    newProfiles = {}
+                    for profileStructMemberValue, profileStructMemberName in profileStructMember.values.items():
+                        for profileName, profile in profiles.items():
+                            # Only add video profile name suffix to the full descriptive name if not empty to avoid excess whitespace
+                            newProfileName = profileName if profileStructMemberName == '' else f'{profileName} {profileStructMemberName}'
+                            newProfiles[newProfileName] = profile + [{
+                                "struct": profileStruct.name,
+                                "member": profileStructMember.name,
+                                "value": profileStructMemberValue
+                            }]
+                    profiles = newProfiles
+
+            for profileName, profile in profiles.items():
+                out.append(f'{" " * 20}add_profile(profile_base_name + "{profileName}", profile_info,\n')
+                out.append(f'{" " * 20}            create_profile_info_chain, create_capabilities_chain,\n')
+                out.append(f'{" " * 20}            create_format_properties_chain_list,\n')
+                out.append(f'{" " * 20}            [](AppVideoProfile& profile) {{\n')
+                for profileStruct in videoCodec.profiles:
+                    structDef = self.vk.structs[profileStruct]
+                    out.append(self.AddGuardHeader(structDef))
+                    for elem in profile:
+                        if elem['struct'] == profileStruct:
+                            out.append(f'{" " * 24}profile.profile_info_chain->{elem["struct"][2:]}.{elem["member"]} = {elem["value"]};\n')
+                    out.append(self.AddGuardFooter(structDef))
+                out.append(f'{" " * 20}}});\n')
+
+            out.append(f'{" " * 16}}}\n')
+            out.append(f'{" " * 12}}}\n')
+            out.append(f'{" " * 8}}}\n')
+            out.append(f'{" " * 4}}}\n')
+
+        out.append('    return result;\n')
+        out.append('}\n\n')
+
+        return out
+
+
+    # finds all the ranges of formats from core (1.0), core versions (1.1+), and extensions
+    def findFormatRanges(self):
+        min_val = 2**32
+        prev_field = None
+        max_val = 0
+        for f in self.vk.enums['VkFormat'].fields:
+            if f.value is None:
+                continue
+            if prev_field is not None and f.value != prev_field.value + 1:
+                for ext in prev_field.extensions:
+                    if self.vk.extensions[ext].promotedTo is not None:
+                        self.format_ranges.append(VulkanFormatRange(self.vk.extensions[ext].promotedTo.replace("VK_", "VK_API_"), [], min_val, max_val))
+                        break
+                # only bother with the first extension
+                self.format_ranges.append(VulkanFormatRange(0, prev_field.extensions, min_val, max_val))
+                min_val = 2**32
+                max_val = 0
+            min_val = min(min_val, f.value)
+            max_val = max(max_val, f.value)
+
+            prev_field = f
+
+        for ext in prev_field.extensions:
+            if self.vk.extensions[ext].promotedTo is not None:
+                self.format_ranges.append(VulkanFormatRange(self.vk.extensions[ext].promotedTo.replace("VK_", "VK_API_"), [], min_val, max_val))
+                break
+
+        self.format_ranges.append(VulkanFormatRange(0, prev_field.extensions, min_val, max_val))
+
+    def findAllTypesToGen(self, initial_type_set):
+        out_set = set()
+        current_set = initial_type_set
+        while len(current_set) > 0:
+            out_set.update(current_set)
+            next_set = set()
+
+            for current_item in current_set:
+                if current_item in self.vk.structs:
+                    for member in self.vk.structs[current_item].members:
+                        if member.type not in out_set and member.name not in NAMES_TO_IGNORE:
+                            next_set.add(member.type)
+
+            current_set = next_set
+        return out_set
+
+    def AddGuardHeader(self,obj):
+        if obj is not None and obj.protect is not None:
+            return f'#ifdef {obj.protect}\n'
+        else:
+            return ''
+
+
+    def AddGuardFooter(self,obj):
+        if obj is not None and obj.protect is not None:
+            return f'#endif  // {obj.protect}\n'
+        else:
+            return ''
+
+    def PrintEnumToString(self,enum):
+        out = []
+        out.append(self.AddGuardHeader(enum))
+        out.append(f'std::string {enum.name}String({enum.name} value) {{\n')
+        out.append('    switch (value) {\n')
+        for v in enum.fields:
+            out.append(f'        case ({v.name}): return "{v.name[3:]}";\n')
+        out.append(f'        default: return std::string("UNKNOWN_{enum.name}_value") + std::to_string(value);\n')
+        out.append('    }\n}\n')
+        out.append(self.AddGuardFooter(enum))
+        return out
+
+
+    def PrintEnum(self,enum):
+        out = []
+        out.append(self.AddGuardHeader(enum))
+        out.append(f'''void Dump{enum.name}(Printer &p, std::string name, {enum.name} value) {{
+    if (p.Type() == OutputType::json)
+        p.PrintKeyString(name, std::string("VK_") + {enum.name}String(value));
+    else
+        p.PrintKeyString(name, {enum.name}String(value));
+}}
+''')
+        out.append(self.AddGuardFooter(enum))
+        return out
+
+
+    def PrintGetFlagStrings(self,name, bitmask):
+        out = []
+        out.append(f'std::vector<const char *> {name}GetStrings({name} value) {{\n')
+        out.append('    std::vector<const char *> strings;\n')
+        # If a bitmask contains a field whose value is zero, we want to support printing the correct bitflag
+        # Otherwise, use "None" for when there are not bits set in the bitmask
+        if bitmask.flags[0].value != 0:
+            out.append('    if (value == 0) { strings.push_back("None"); return strings; }\n')
+        else:
+            out.append(f'    if (value == 0) {{ strings.push_back("{bitmask.flags[0].name[3:]}"); return strings; }}\n')
+        for v in bitmask.flags:
+            # only check single-bit flags
+            if v.value != 0 and (v.value & (v.value - 1)) == 0:
+                out.append(f'    if ({v.name} & value) strings.push_back("{v.name[3:]}");\n')
+        out.append('    return strings;\n}\n')
+        return out
+
+
+    def PrintFlags(self, bitmask, name):
+        out = []
+        out.append(f'void Dump{name}(Printer &p, std::string name, {name} value) {{\n')
+        out.append(f'''    if (static_cast<{bitmask.name}>(value) == 0) {{
+        ArrayWrapper arr(p, name, 0);
+        if (p.Type() != OutputType::json && p.Type() != OutputType::vkconfig_output)
+            p.SetAsType().PrintString("None");
+        return;
+    }}
+    auto strings = {bitmask.name}GetStrings(static_cast<{bitmask.name}>(value));
+    ArrayWrapper arr(p, name, strings.size());
+    for(auto& str : strings){{
+        if (p.Type() == OutputType::json)
+            p.SetAsType().PrintString(std::string("VK_") + str);
+        else
+            p.SetAsType().PrintString(str);
+    }}
+}}
+''')
+        return out
+
+
+    def PrintFlagBits(self, bitmask):
+        return [f'''void Dump{bitmask.name}(Printer &p, std::string name, {bitmask.name} value) {{
+    auto strings = {bitmask.name}GetStrings(value);
+    if (strings.size() > 0) {{
+        if (p.Type() == OutputType::json)
+            p.PrintKeyString(name, std::string("VK_") + strings.at(0));
+        else
+            p.PrintKeyString(name, strings.at(0));
+    }}
+}}
+''']
+
+
+    def PrintBitMask(self,bitmask, name):
+        out = []
+        out.extend(self.PrintGetFlagStrings(bitmask.name, bitmask))
+        out.append(self.AddGuardHeader(bitmask))
+        out.extend(self.PrintFlags(bitmask, name))
+        out.extend(self.PrintFlagBits(bitmask))
+        out.append(self.AddGuardFooter(bitmask))
+        out.append('\n')
+        return out
+
+
+    def PrintBitMaskToString(self, bitmask, name):
+        out = []
+        out.append(self.AddGuardHeader(bitmask))
+        out.append(f'std::string {name}String({name} value) {{\n')
+        out.append('    std::string out;\n')
+        out.append('    bool is_first = true;\n')
+        for v in bitmask.flags:
+            out.append(f'    if ({v.name} & value) {{\n')
+            out.append('        if (is_first) { is_first = false; } else { out += " | "; }\n')
+            out.append(f'        out += "{str(v.name)[3:]}";\n')
+            out.append('    }\n')
+        out.append('    return out;\n')
+        out.append('}\n')
+        out.append(self.AddGuardFooter(bitmask))
+        return out
+
+
+    def PrintStructure(self,struct, declare_only):
+        if len(struct.members) == 0:
+            return []
+        out = []
+        out.append(self.AddGuardHeader(struct))
+        max_key_len = 0
+        for v in struct.members:
+            if (v.type in PREDEFINED_TYPES or v.type in STRUCT_BLACKLIST) and (v.length is None or v.type in ['char'] or v.fixedSizeArray[0] in ['VK_UUID_SIZE', 'VK_LUID_SIZE']):
+                max_key_len = max(max_key_len, len(v.name))
+        out.append(f'void Dump{struct.name}(Printer &p, std::string name, const {struct.name} &obj)')
+        if declare_only:
+            out.append(';\n')
+            out.append(self.AddGuardFooter(struct))
+            return out
+        out.append(' {\n')
+        if struct.name == 'VkPhysicalDeviceLimits':
+            out.append('    if (p.Type() == OutputType::json)\n')
+            out.append('        p.ObjectStart("limits");\n')
+            out.append('    else\n')
+            out.append('        p.SetSubHeader().ObjectStart(name);\n')
+        elif struct.name == 'VkPhysicalDeviceSparseProperties':
+            out.append('    if (p.Type() == OutputType::json)\n')
+            out.append('        p.ObjectStart("sparseProperties");\n')
+            out.append('    else\n')
+            out.append('        p.SetSubHeader().ObjectStart(name);\n')
+        else:
+            out.append('    ObjectWrapper object{p, name};\n')
+        if max_key_len > 0:
+            out.append(f'    p.SetMinKeyWidth({max_key_len});\n')
+        for v in struct.members:
+            # strings
+            if v.type == 'char':
+                if v.pointer == True:
+                    out.append(f'    if (obj.{v.name} == nullptr) {{')
+                    out.append(f'        p.PrintKeyString("{v.name}", "NULL");\n')
+                    out.append('    } else {')
+                out.append(f'    p.PrintKeyString("{v.name}", obj.{v.name});\n')
+                if v.pointer == True:
+                        out.append('    }')
+            # arrays
+            elif v.length is not None:
+                # uuid's
+                if v.type == 'uint8_t' and (v.fixedSizeArray[0] == 'VK_LUID_SIZE' or v.fixedSizeArray[0] == 'VK_UUID_SIZE'):  # VK_UUID_SIZE
+                    if v.fixedSizeArray[0] == 'VK_LUID_SIZE':
+                        out.append('    if (obj.deviceLUIDValid) { // special case\n')
+                    out.append(f'    p.PrintKeyValue("{v.name}", obj.{v.name});\n')
+                    if v.fixedSizeArray[0] == 'VK_LUID_SIZE':
+                        out.append('    }\n')
+                elif struct.name == 'VkQueueFamilyGlobalPriorityProperties' and v.name == 'priorities':
+                    out.append(f'    ArrayWrapper arr(p,"{v.name}", obj.priorityCount);\n')
+                    out.append('    for (uint32_t i = 0; i < obj.priorityCount; i++) {\n')
+                    out.append('       if (p.Type() == OutputType::json)\n')
+                    out.append('           p.PrintString(std::string("VK_") + VkQueueGlobalPriorityString(obj.priorities[i]));\n')
+                    out.append('       else\n')
+                    out.append('           p.PrintString(VkQueueGlobalPriorityString(obj.priorities[i]));\n')
+                    out.append('    }\n')
+                elif len(v.fixedSizeArray) == 2:
+                    out.append(f'    {{\n        ArrayWrapper arr(p,"{v.name}", ' + v.fixedSizeArray[0] + ');\n')
+                    out.append(f'        for (uint32_t i = 0; i < {v.fixedSizeArray[0]}; i++) {{\n')
+                    out.append(f'           for (uint32_t j = 0; j < {v.fixedSizeArray[1]}; j++) {{\n')
+                    out.append(f'                p.PrintElement(obj.{v.name}[i][j]); }} }}\n')
+                    out.append('    }\n')
+                elif len(v.fixedSizeArray) == 1:
+                    out.append(f'    {{\n        ArrayWrapper arr(p,"{v.name}", ' + v.fixedSizeArray[0] + ');\n')
+                    out.append(f'        for (uint32_t i = 0; i < {v.fixedSizeArray[0]}; i++) {{ p.PrintElement(obj.{v.name}[i]); }}\n')
+                    out.append('    }\n')
+                else:  # dynamic array length based on other member
+                    out.append(f'    if (obj.{v.length} == 0 || obj.{v.name} == nullptr) {{\n')
+                    out.append(f'        p.PrintKeyString("{v.name}", "NULL");\n')
+                    out.append('    } else {\n')
+                    out.append(f'        ArrayWrapper arr(p,"{v.name}", obj.{v.length});\n')
+                    out.append(f'        for (uint32_t i = 0; i < obj.{v.length}; i++) {{\n')
+                    out.append(f'            Dump{v.type}(p, std::to_string(i), obj.{v.name}[i]);\n')
+                    out.append('        }\n')
+                    out.append('    }\n')
+            elif v.type == 'VkBool32':
+                out.append(f'    p.PrintKeyBool("{v.name}", static_cast<bool>(obj.{v.name}));\n')
+            elif v.type == 'uint8_t':
+                out.append(f'    p.PrintKeyValue("{v.name}", static_cast<uint32_t>(obj.{v.name}));\n')
+            elif v.type == 'VkDeviceSize' or (v.type == 'uint32_t' and v.name in ['vendorID', 'deviceID']):
+                out.append(f'    p.PrintKeyValue("{v.name}", to_hex_str(p, obj.{v.name}));\n')
+            elif v.type in PREDEFINED_TYPES:
+                out.append(f'    p.PrintKeyValue("{v.name}", obj.{v.name});\n')
+            elif v.name not in NAMES_TO_IGNORE:
+                # if it is an enum/flag/bitmask
+                if v.type in ['VkFormatFeatureFlags', 'VkFormatFeatureFlags2']:
+                    out.append('    p.SetOpenDetails();\n') # special case so that feature flags are open in html output
+                out.append(f'    Dump{v.type}(p, "{v.name}", obj.{v.name});\n')
+
+        if struct.name in ['VkPhysicalDeviceLimits', 'VkPhysicalDeviceSparseProperties']:
+            out.append('    p.ObjectEnd();\n')
+        out.append('}\n')
+
+        out.append(self.AddGuardFooter(struct))
+        return out
+
+
+    def PrintStructShort(self,struct):
+        out = []
+        out.append(self.AddGuardHeader(struct))
+        out.append(f'std::ostream &operator<<(std::ostream &o, {struct.name} &obj) {{\n')
+        out.append('    return o << "(" << ')
+
+        first = True
+        for v in struct.members:
+            if first:
+                first = False
+                out.append(f'obj.{v.name} << ')
+            else:
+                out.append(f'\',\' << obj.{v.name} << ')
+        out.append('")";\n')
+        out.append('}\n')
+        out.append(self.AddGuardFooter(struct))
+        return out
+
+    def PrintChainStruct(self, listName, structs_to_print, chain_details):
+        version_desc = ''
+        if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]:
+            version_desc = 'gpu.api_version'
+        else:
+            version_desc = 'inst.instance_version'
+
+        out = []
+
+        # use default constructor and delete copy & move operators
+        out.append(f'''struct {listName}_chain {{
+    {listName}_chain() = default;
+    {listName}_chain(const {listName}_chain &) = delete;
+    {listName}_chain& operator=(const {listName}_chain &) = delete;
+    {listName}_chain({listName}_chain &&) = delete;
+    {listName}_chain& operator=({listName}_chain &&) = delete;
+''')
+
+        out.append('    void* start_of_chain = nullptr;\n')
+        for s in structs_to_print:
+            if s in STRUCT_BLACKLIST:
+                continue
+            struct = self.vk.structs[s]
+            out.append(self.AddGuardHeader(struct))
+            if struct.sType is not None:
+                out.append(f'    {struct.name} {struct.name[2:]}{{}};\n')
+                # Specific versions of drivers have an incorrect definition of the size of these structs.
+                # We need to artificially pad the structure it just so the driver doesn't write out of bounds and
+                # into other structures that are adjacent. This bug comes from the in-development version of
+                # the extension having a larger size than the final version, so older drivers try to write to
+                # members which don't exist.
+                if struct.name in ['VkPhysicalDeviceShaderIntegerDotProductFeatures', 'VkPhysicalDeviceHostImageCopyFeaturesEXT']:
+                    out.append(f'    char {struct.name}_padding[64];\n')
+                for member in struct.members:
+                    if member.length is not None and len(member.fixedSizeArray) == 0:
+                        out.append(f'    std::vector<{member.type}> {struct.name}_{member.name};\n')
+            out.append(self.AddGuardFooter(struct))
+        out.append('    void initialize_chain(')
+        args = []
+        if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]:
+            args.append('AppInstance &inst')
+        if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]:
+            args.append('AppGpu &gpu')
+        if chain_details.get('can_show_promoted_structs'):
+            args.append('bool show_promoted_structs')
+        out.append(f'{", ".join(args)}) noexcept {{\n')
+        for s in structs_to_print:
+            if s in STRUCT_BLACKLIST:
+                continue
+            struct = self.vk.structs[s]
+
+            out.append(self.AddGuardHeader(struct))
+            out.append(f'        {struct.name[2:]}.sType = {struct.sType};\n')
+            out.append(self.AddGuardFooter(struct))
+
+        out.append('        std::vector<VkBaseOutStructure*> chain_members{};\n')
+        for s in structs_to_print:
+            if s in STRUCT_BLACKLIST:
+                continue
+            struct = self.vk.structs[s]
+            out.append(self.AddGuardHeader(struct))
+
+            has_version = struct.version is not None
+            has_extNameStr = len(struct.extensions) > 0 or len(struct.aliases) > 0
+            if has_version or has_extNameStr:
+                out.append('        if (')
+                has_printed_condition = False
+                if has_extNameStr:
+                    for ext in struct.extensions:
+                        if has_printed_condition:
+                            out.append('\n         || ')
+                        else:
+                            has_printed_condition = True
+                            if has_version:
+                                out.append('(')
+                        if self.vk.extensions[ext].device:
+                            out.append(f'gpu.CheckPhysicalDeviceExtensionIncluded({self.vk.extensions[ext].nameString})')
+                        elif self.vk.extensions[ext].instance:
+                            out.append(f'inst.CheckExtensionEnabled({self.vk.extensions[ext].nameString})')
+                        else:
+                            assert False, 'Should never get here'
+                if has_version:
+                    str_show_promoted_structs = '|| show_promoted_structs' if chain_details.get('can_show_promoted_structs') else ''
+                    if struct.name in STRUCT_1_1_LIST:
+                        out.append(f'{version_desc} == {struct.version.nameApi} {str_show_promoted_structs}')
+                    elif has_printed_condition:
+                        out.append(f')\n            && ({version_desc} < {struct.version.nameApi} {str_show_promoted_structs})')
+                    else:
+                        out.append(f'({version_desc} >= {struct.version.nameApi})')
+                out.append(')\n            ')
+            else:
+                out.append('        ')
+            out.append(f'chain_members.push_back(reinterpret_cast<VkBaseOutStructure*>(&{struct.name[2:]}));\n')
+            out.append(self.AddGuardFooter(struct))
+        chain_param_list = []
+        chain_arg_list = []
+        if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]:
+            chain_param_list.append('AppInstance &inst')
+            chain_arg_list.append('inst')
+        if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]:
+            chain_param_list.append('AppGpu &gpu')
+            chain_arg_list.append('gpu')
+        if chain_details.get('can_show_promoted_structs'):
+            chain_param_list.append('bool show_promoted_structs')
+            chain_arg_list.append('show_promoted_structs')
+
+        out.append(f'''
+        if (!chain_members.empty()) {{
+            for(size_t i = 0; i < chain_members.size() - 1; i++){{
+                chain_members[i]->pNext = chain_members[i + 1];
+            }}
+            start_of_chain = chain_members[0];
+        }}
+    }}
+}};
+void setup_{listName}_chain({chain_details['extends']}& start, std::unique_ptr<{listName}_chain>& chain, {','.join(chain_param_list)}){{
+    chain = std::unique_ptr<{listName}_chain>(new {listName}_chain());
+    chain->initialize_chain({','.join(chain_arg_list)});
+    start.pNext = chain->start_of_chain;
+}};
+''')
+        if chain_details.get('print_iterator'):
+            out.append('\n')
+            out.append(f'void chain_iterator_{listName}(')
+            args = ['Printer &p']
+            if chain_details.get('type') in [EXTENSION_TYPE_INSTANCE, EXTENSION_TYPE_BOTH]:
+                args.append('AppInstance &inst')
+            if chain_details.get('type') in [EXTENSION_TYPE_DEVICE, EXTENSION_TYPE_BOTH]:
+                args.append('AppGpu &gpu')
+            if chain_details.get('can_show_promoted_structs'):
+                args.append('bool show_promoted_structs')
+            args.append('const void * place')
+            out.append(f'{", ".join(args)}) {{\n')
+            out.append('    while (place) {\n')
+            out.append('        const VkBaseOutStructure *structure = (const VkBaseOutStructure *)place;\n')
+            out.append('        p.SetSubHeader();\n')
+
+            for s in structs_to_print:
+                if s in STRUCT_BLACKLIST:
+                    continue
+                struct = self.vk.structs[s]
+
+                out.append(self.AddGuardHeader(struct))
+                out.append(f'        if (structure->sType == {struct.sType}')
+                if struct.name in PORTABILITY_STRUCTS:
+                    out.append(' && p.Type() != OutputType::json')
+                out.append(') {\n')
+                out.append(f'            const {struct.name}* props = (const {struct.name}*)structure;\n')
+                out.extend(self.PrintStructNameDecisionLogic(struct, version_desc, chain_details.get('can_show_promoted_structs')))
+                out.append('            p.AddNewline();\n')
+                out.append('        }\n')
+                out.append(self.AddGuardFooter(struct))
+            out.append('        place = structure->pNext;\n')
+            out.append('    }\n')
+            out.append('}\n')
+
+        out.append('\n')
+        out.append(f'bool prepare_{listName}_twocall_chain_vectors(std::unique_ptr<{listName}_chain>& chain) {{\n')
+        out.append('    (void)chain;\n')
+        is_twocall = False
+        for s in structs_to_print:
+            if s in STRUCT_BLACKLIST:
+                continue
+            struct = self.vk.structs[s]
+            has_length = False
+            for member in struct.members:
+                if member.length is not None and len(member.fixedSizeArray) == 0:
+                    has_length = True
+            if not has_length:
+                continue
+            out.append(self.AddGuardHeader(struct))
+            for member in struct.members:
+                if member.length is not None and len(member.fixedSizeArray) == 0:
+                    out.append(f'    chain->{struct.name}_{member.name}.resize(chain->{struct.name[2:]}.{member.length});\n')
+                    out.append(f'    chain->{struct.name[2:]}.{member.name} = chain->{struct.name}_{member.name}.data();\n')
+            out.append(self.AddGuardFooter(struct))
+            is_twocall = True
+        out.append(f'    return {"true" if is_twocall else "false"};\n')
+        out.append('}\n')
+
+        return out
+
+    def GetStructCheckStringForMatchingExtension(self, struct, structName):
+        for ext_name in struct.extensions:
+            ext = self.vk.extensions[ext_name]
+            vendor = ext.name.split('_')[1]
+            if structName.endswith(vendor):
+                if ext.device:
+                    return f'gpu.CheckPhysicalDeviceExtensionIncluded({ext.nameString})'
+                elif ext.instance:
+                    return f'inst.CheckExtensionEnabled({ext.nameString})'
+        return None
+
+    # Function is complex because it has to do the following:
+    # Always print the struct with the most appropriate name given the gpu api version & enabled instance/device extensions
+    # Print struct aliases when --show-promoted-structs is set
+    # Not let alias printing duplicate the most appropriate name
+    def PrintStructNameDecisionLogic(self, struct, version_desc, can_show_promoted_structs):
+        out = []
+        out.append(f'{" " * 12}const char* name = ')
+        # Get a list of all the conditions to check and the type name to use
+        check_list = []
+        if struct.version is not None:
+            check_list.append([f'{version_desc} >= {struct.version.nameApi}', struct.name])
+        else:
+            check_list.append([f'{self.GetStructCheckStringForMatchingExtension(struct, struct.name)}', struct.name])
+
+        for alias in struct.aliases:
+            ext_str = self.GetStructCheckStringForMatchingExtension(struct, alias)
+            if ext_str is not None:
+                check_list.append([f'{self.GetStructCheckStringForMatchingExtension(struct, alias)}', alias])
+        end_parens = ''
+        # Turn the conditions into a nested ternary condition -
+        for check in check_list:
+            if check == check_list[-1]:
+                out.append( f'"{check[1]}"')
+            else:
+                out.append( f'{check[0]} ? "{check[1]}" : (')
+                end_parens += ')'
+        out.append(f'{end_parens};\n')
+        out.append(f'{" " * 12}Dump{struct.name}(p, name, *props);\n')
+        if not can_show_promoted_structs:
+            return out
+        for alias in struct.aliases:
+            ext_str = self.GetStructCheckStringForMatchingExtension(struct, alias)
+            if ext_str is not None:
+                out.append(f'{" " * 12}if (show_promoted_structs && strcmp(name, "{alias}") != 0 && {ext_str}) {{\n')
+                out.append(f'{" " * 16}p.AddNewline();\n')
+                out.append(f'{" " * 16}p.SetSubHeader();\n')
+                out.append(f'{" " * 16}Dump{struct.name}(p, "{alias}", *props);\n')
+                out.append(f'{" " * 12}}}\n')
+        return out
+
+    def PrintStructComparisonForwardDecl(self,structure):
+        out = []
+        out.append(f'bool operator==(const {structure.name} & a, const {structure.name} b);\n')
+        return out
+
+
+    def PrintStructComparison(self,structure):
+        out = []
+        out.append(f'bool operator==(const {structure.name} & a, const {structure.name} b) {{\n')
+        out.append('    return ')
+        is_first = True
+        for m in structure.members:
+            if m.name not in NAMES_TO_IGNORE:
+                if not is_first:
+                    out.append('\n        && ')
+                else:
+                    is_first = False
+                out.append(f'a.{m.name} == b.{m.name}')
+        out.append(';\n')
+        out.append('}\n')
+        return out
+
+class VulkanFormatRange:
+    def __init__(self, min_inst_version, extensions, first, last):
+        self.minimum_instance_version = min_inst_version
+        self.extensions = extensions
+        self.first_format = first
+        self.last_format = last
diff --git a/tools/Vulkan-Tools/scripts/gn/DEPS b/tools/Vulkan-Tools/scripts/gn/DEPS
new file mode 100644
index 00000000..8cf931a8
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/DEPS
@@ -0,0 +1,68 @@
+gclient_gn_args_file = 'build/config/gclient_args.gni'
+
+vars = {
+  'chromium_git': 'https://chromium.googlesource.com',
+  'ninja_version': 'version:2@1.11.1.chromium.6',
+}
+
+deps = {
+
+  'build': {
+    'url': '{chromium_git}/chromium/src/build.git@1015724d82945f9ef7e51c6f804034ccf5f79951',
+  },
+
+  'buildtools': {
+    'url': '{chromium_git}/chromium/src/buildtools.git@3c7e3f1b8b1e4c0b6ec693430379cea682de78d6',
+  },
+
+  'buildtools/linux64': {
+    'packages': [
+      {
+        'package': 'gn/gn/linux-${{arch}}',
+        'version': 'git_revision:5e19d2fb166fbd4f6f32147fbb2f497091a54ad8',
+      }
+    ],
+    'dep_type': 'cipd',
+    'condition': 'host_os == "linux"',
+  },
+
+  'testing': {
+    'url': '{chromium_git}/chromium/src/testing@949b2864b6bd27656753b917c9aa7731dc7a06f6',
+  },
+
+  'tools/clang': {
+    'url': '{chromium_git}/chromium/src/tools/clang.git@566877f1ff1a5fa6beaca3ab4b47bd0b92eb614f',
+  },
+
+  'third_party/ninja': {
+    'packages': [
+      {
+        'package': 'infra/3pp/tools/ninja/${{platform}}',
+        'version': Var('ninja_version'),
+      }
+    ],
+    'dep_type': 'cipd',
+  },
+
+}
+
+hooks = [
+  {
+    'name': 'sysroot_x64',
+    'pattern': '.',
+    'condition': 'checkout_linux and checkout_x64',
+    'action': ['python3', 'build/linux/sysroot_scripts/install-sysroot.py',
+               '--arch=x64'],
+  },
+  {
+    # Note: On Win, this should run after win_toolchain, as it may use it.
+    'name': 'clang',
+    'pattern': '.',
+    'action': ['python3', 'tools/clang/scripts/update.py'],
+  },
+]
+
+recursedeps = [
+  # buildtools provides clang_format.
+  'buildtools',
+]
diff --git a/tools/Vulkan-Tools/scripts/gn/generate_vulkan_icd_json.py b/tools/Vulkan-Tools/scripts/gn/generate_vulkan_icd_json.py
new file mode 100755
index 00000000..467ba616
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/generate_vulkan_icd_json.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2022-2023 LunarG, Inc.
+# Copyright (C) 2016 The ANGLE Project Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generate copies of the Vulkan layers JSON files, with no paths, forcing
+Vulkan to use the default search path to look for layers."""
+
+from __future__ import print_function
+
+import argparse
+import glob
+import json
+import os
+import platform
+import sys
+
+def glob_slash(dirname):
+    r"""Like regular glob but replaces \ with / in returned paths."""
+    return [s.replace('\\', '/') for s in glob.glob(dirname)]
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--icd', action='store_true')
+    parser.add_argument('--no-path-prefix', action='store_true')
+    parser.add_argument('--platform', type=str, default=platform.system(),
+        help='Target platform to build validation layers for: '
+             'Linux|Darwin|Windows|Fuchsia|...')
+    parser.add_argument('source_dir')
+    parser.add_argument('target_dir')
+    parser.add_argument('json_files', nargs='*')
+    args = parser.parse_args()
+
+    source_dir = args.source_dir
+    target_dir = args.target_dir
+
+    json_files = [j for j in args.json_files if j.endswith('.json')]
+    json_in_files = [j for j in args.json_files if j.endswith('.json.in')]
+
+    data_key = 'ICD' if args.icd else 'layer'
+
+    if not os.path.isdir(source_dir):
+        print(source_dir + ' is not a directory.', file=sys.stderr)
+        return 1
+
+    if not os.path.exists(target_dir):
+        os.makedirs(target_dir)
+
+    # Copy the *.json files from source dir to target dir
+    if (set(glob_slash(os.path.join(source_dir, '*.json'))) != set(json_files)):
+        print(glob.glob(os.path.join(source_dir, '*.json')))
+        print('.json list in gn file is out-of-date', file=sys.stderr)
+        return 1
+
+    for json_fname in json_files:
+        if not json_fname.endswith('.json'):
+            continue
+        with open(json_fname) as infile:
+            data = json.load(infile)
+
+        # Update the path.
+        if not data_key in data:
+            raise Exception(
+                "Could not find '%s' key in %s" % (data_key, json_fname))
+
+        # The standard validation layer has no library path.
+        if 'library_path' in data[data_key]:
+            prev_name = os.path.basename(data[data_key]['library_path'])
+            data[data_key]['library_path'] = prev_name
+
+        target_fname = os.path.join(target_dir, os.path.basename(json_fname))
+        with open(target_fname, 'w') as outfile:
+            json.dump(data, outfile)
+
+    # Set json file prefix and suffix for generating files, default to Linux.
+    if args.no_path_prefix:
+        relative_path_prefix = ''
+    elif args.platform == 'Windows':
+        relative_path_prefix = r'..\\'  # json-escaped, hence two backslashes.
+    else:
+        relative_path_prefix = '../lib'
+    file_type_suffix = '.so'
+    if args.platform == 'Windows':
+        file_type_suffix = '.dll'
+    elif args.platform == 'Darwin':
+        file_type_suffix = '.dylib'
+
+    # For each *.json.in template files in source dir generate actual json file
+    # in target dir
+    if (set(glob_slash(os.path.join(source_dir, '*.json.in'))) !=
+            set(json_in_files)):
+        print('.json.in list in gn file is out-of-date', file=sys.stderr)
+        return 1
+    for json_in_name in json_in_files:
+        if not json_in_name.endswith('.json.in'):
+            continue
+        json_in_fname = os.path.basename(json_in_name)
+        layer_name = json_in_fname[:-len('.json.in')]
+        layer_lib_name = layer_name + file_type_suffix
+        json_out_fname = os.path.join(target_dir, json_in_fname[:-len('.in')])
+        with open(json_out_fname,'w') as json_out_file, \
+             open(json_in_name) as infile:
+            for line in infile:
+                line = line.replace('@JSON_LIBRARY_PATH@', relative_path_prefix + layer_lib_name)
+                json_out_file.write(line)
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/tools/Vulkan-Tools/scripts/gn/gn.py b/tools/Vulkan-Tools/scripts/gn/gn.py
new file mode 100755
index 00000000..52b20c58
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/gn.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import subprocess
+import sys
+
+# helper to define paths relative to the repo root
+def RepoRelative(path):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), '../../', path))
+
+def BuildGn():
+    if not os.path.exists(RepoRelative("depot_tools")):
+        print("Cloning Chromium depot_tools\n", flush=True)
+        clone_cmd = 'git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git depot_tools'.split(" ")
+        subprocess.call(clone_cmd)
+
+    os.environ['PATH'] = os.environ.get('PATH') + ":" + RepoRelative("depot_tools")
+
+    print("Updating Repo Dependencies and GN Toolchain\n", flush=True)
+    update_cmd = './scripts/gn/update_deps.sh'
+    subprocess.call(update_cmd)
+
+    print("Checking Header Dependencies\n", flush=True)
+    gn_check_cmd = 'gn gen --check out/Debug'.split(" ")
+    subprocess.call(gn_check_cmd)
+
+    print("Generating Ninja Files\n", flush=True)
+    gn_gen_cmd = 'gn gen out/Debug'.split(" ")
+    subprocess.call(gn_gen_cmd)
+
+    print("Running Ninja Build\n", flush=True)
+    ninja_build_cmd = 'ninja -C out/Debug'.split(" ")
+    subprocess.call(ninja_build_cmd)
+
+#
+# Module Entrypoint
+def main():
+    try:
+        BuildGn()
+
+    except subprocess.CalledProcessError as proc_error:
+        print('Command "%s" failed with return code %s' % (' '.join(proc_error.cmd), proc_error.returncode))
+        sys.exit(proc_error.returncode)
+    except Exception as unknown_error:
+        print('An unkown error occured: %s', unknown_error)
+        sys.exit(1)
+
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/build.gni b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/build.gni
new file mode 100644
index 00000000..dbf47039
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/build.gni
@@ -0,0 +1,18 @@
+# Copyright (c) 2019-2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+build_with_chromium = false
+ignore_elf32_limitations = true
+linux_use_bundled_binutils_override = false
+use_system_xcode = true
diff --git a/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_headers.gni b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_headers.gni
new file mode 100644
index 00000000..5f24b39e
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_headers.gni
@@ -0,0 +1,15 @@
+# Copyright (c) 2020-2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+vulkan_use_x11 = true
diff --git a/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_tools.gni b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_tools.gni
new file mode 100644
index 00000000..c62fb64d
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/secondary/build_overrides/vulkan_tools.gni
@@ -0,0 +1,21 @@
+# Copyright (c) 2019-2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Paths to vulkan tools dependencies
+vulkan_headers_dir = "//external/Vulkan-Headers"
+
+# Subdirectories for generated files
+vulkan_data_subdir = ""
+vulkan_gen_subdir = ""
+
diff --git a/tools/Vulkan-Tools/scripts/gn/update_deps.sh b/tools/Vulkan-Tools/scripts/gn/update_deps.sh
new file mode 100755
index 00000000..763c3058
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/gn/update_deps.sh
@@ -0,0 +1,49 @@
+#!/bin/sh
+
+# Copyright (c) 2019-2023 LunarG, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Execute at repo root
+cd "$(dirname $0)/../../"
+
+# Use update_deps.py to update source dependencies from /scripts/known_good.json
+scripts/update_deps.py --dir="external" --no-build
+
+cat << EOF > .gn
+buildconfig = "//build/config/BUILDCONFIG.gn"
+secondary_source = "//scripts/gn/secondary/"
+
+script_executable = "python3"
+
+default_args = {
+    clang_use_chrome_plugins = false
+    use_custom_libcxx = false
+}
+EOF
+
+# Use gclient to update toolchain dependencies from /scripts/gn/DEPS (from chromium)
+cat << EOF >> .gclient
+solutions = [
+  { "name"        : ".",
+    "url"         : "https://github.com/KhronosGroup/Vulkan-Tools",
+    "deps_file"   : "scripts/gn/DEPS",
+    "managed"     : False,
+    "custom_deps" : {
+    },
+    "custom_vars": {},
+  },
+]
+EOF
+gclient sync
+
diff --git a/tools/Vulkan-Tools/scripts/known_good.json b/tools/Vulkan-Tools/scripts/known_good.json
new file mode 100644
index 00000000..14e6f5b8
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/known_good.json
@@ -0,0 +1,79 @@
+{
+    "repos": [
+        {
+            "name": "Vulkan-Headers",
+            "api": "vulkan",
+            "url": "https://github.com/KhronosGroup/Vulkan-Headers.git",
+            "sub_dir": "Vulkan-Headers",
+            "build_dir": "Vulkan-Headers/build",
+            "install_dir": "Vulkan-Headers/build/install",
+            "commit": "v1.4.347"
+        },
+        {
+            "name": "MoltenVK",
+            "url": "https://github.com/KhronosGroup/MoltenVK.git",
+            "sub_dir": "MoltenVK",
+            "build_dir": "MoltenVK",
+            "install_dir": "MoltenVK",
+            "commit": "v1.4.1",
+            "custom_build": [
+                "./fetchDependencies --macos",
+                "xcodebuild -project MoltenVKPackaging.xcodeproj GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS MVK_CONFIG_LOG_LEVEL=1' -scheme \"MoltenVK Package (macOS only)\" build"
+            ],
+            "build_step": "custom",
+            "build_platforms": [
+                "darwin"
+            ]
+        },
+        {
+            "name": "googletest",
+            "url": "https://github.com/google/googletest.git",
+            "sub_dir": "googletest",
+            "build_dir": "googletest/build",
+            "install_dir": "googletest/build/install",
+            "cmake_options": [
+                "-DBUILD_GMOCK=OFF",
+                "-Dgtest_force_shared_crt=ON",
+                "-DBUILD_SHARED_LIBS=OFF"
+            ],
+            "build_platforms": [
+                "windows",
+                "linux",
+                "darwin"
+            ],
+            "commit": "v1.14.0",
+            "optional": [
+                "tests"
+            ]
+        },
+        {
+            "name": "Vulkan-Loader",
+            "api": "vulkan",
+            "url": "https://github.com/KhronosGroup/Vulkan-Loader.git",
+            "sub_dir": "Vulkan-Loader",
+            "build_dir": "Vulkan-Loader/build",
+            "install_dir": "Vulkan-Loader/build/install",
+            "cmake_options": [
+                "-DLOADER_USE_UNSAFE_FILE_SEARCH=ON"
+            ],
+            "commit": "v1.4.347",
+            "build_platforms": [
+                "windows",
+                "linux",
+                "darwin"
+            ],
+            "deps": [
+                {
+                    "var_name": "VULKAN_HEADERS_INSTALL_DIR",
+                    "repo_name": "Vulkan-Headers"
+                }
+            ]
+        }
+    ],
+    "install_names": {
+        "Vulkan-Headers": "VULKAN_HEADERS_INSTALL_DIR",
+        "MoltenVK": "MOLTENVK_REPO_ROOT",
+        "googletest": "GOOGLETEST_INSTALL_DIR",
+        "Vulkan-Loader": "VULKAN_LOADER_INSTALL_DIR"
+    }
+}
diff --git a/tools/Vulkan-Tools/scripts/kvt_genvk.py b/tools/Vulkan-Tools/scripts/kvt_genvk.py
new file mode 100644
index 00000000..868cc3fb
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/kvt_genvk.py
@@ -0,0 +1,416 @@
+#!/usr/bin/python3
+#
+# Copyright (c) 2013-2025 The Khronos Group Inc.
+# Copyright (c) 2023-2025 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import pdb
+import sys
+import time
+import os
+
+# Simple timer functions
+startTime = None
+
+
+def startTimer(timeit):
+    global startTime
+    if timeit:
+        startTime = time.process_time()
+
+
+def endTimer(timeit, msg):
+    global startTime
+    if timeit:
+        endTime = time.process_time()
+        write(msg, endTime - startTime, file=sys.stderr)
+        startTime = None
+
+# Turn a list of strings into a regexp string matching exactly those strings
+
+
+def makeREstring(list, default=None):
+    if len(list) > 0 or default is None:
+        return '^(' + '|'.join(list) + ')$'
+    else:
+        return default
+
+# Returns a directory of [ generator function, generator options ] indexed
+# by specified short names. The generator options incorporate the following
+# parameters:
+#
+# args is an parsed argument object; see below for the fields that are used.
+
+
+def makeGenOpts(args):
+    global genOpts
+    genOpts = {}
+
+    # API to generate sources for
+    apiname = args.api
+
+    # Default class of extensions to include, or None
+    if args.defaultExtensions is not None:
+        defaultExtensions = args.defaultExtensions
+    else:
+        defaultExtensions = apiname
+
+    # Additional extensions to include (list of extensions)
+    extensions = args.extension
+
+    # Extensions to remove (list of extensions)
+    removeExtensions = args.removeExtensions
+
+    # Extensions to emit (list of extensions)
+    emitExtensions = args.emitExtensions
+
+    # Features to include (list of features)
+    features = args.feature
+
+    # Whether to disable inclusion protect in headers
+    protect = args.protect
+
+    # Output target directory
+    directory = args.directory
+
+    # Path to generated files, particularly api.py
+    genpath = args.genpath
+
+    # Descriptive names for various regexp patterns used to select
+    # versions and extensions
+    allFeatures = allExtensions = '.*'
+    noFeatures = noExtensions = None
+
+    # Turn lists of names/patterns into matching regular expressions
+    addExtensionsPat = makeREstring(extensions, None)
+    removeExtensionsPat = makeREstring(removeExtensions, None)
+    emitExtensionsPat = makeREstring(emitExtensions, allExtensions)
+    featuresPat = makeREstring(features, allFeatures)
+
+    # Copyright text prefixing all headers (list of strings).
+    prefixStrings = [
+        '/*',
+        '** Copyright (c) 2015-2025 The Khronos Group Inc.',
+        '**',
+        '** Licensed under the Apache License, Version 2.0 (the "License");',
+        '** you may not use this file except in compliance with the License.',
+        '** You may obtain a copy of the License at',
+        '**',
+        '**     http://www.apache.org/licenses/LICENSE-2.0',
+        '**',
+        '** Unless required by applicable law or agreed to in writing, software',
+        '** distributed under the License is distributed on an "AS IS" BASIS,',
+        '** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.',
+        '** See the License for the specific language governing permissions and',
+        '** limitations under the License.',
+        '*/',
+        ''
+    ]
+
+    # Text specific to Vulkan headers
+    vkPrefixStrings = [
+        '/*',
+        '** This header is generated from the Khronos Vulkan XML API Registry.',
+        '**',
+        '*/',
+        ''
+    ]
+
+    # Defaults for generating re-inclusion protection wrappers (or not)
+    protectFeature = protect
+
+    # An API style conventions object
+    conventions = VulkanConventions()
+
+    # Helper file generator options for typemap_helper.h
+    genOpts['vk_typemap_helper.h'] = [
+        HelperFileOutputGenerator,
+        HelperFileOutputGeneratorOptions(
+            conventions=conventions,
+            filename='vk_typemap_helper.h',
+            directory=directory,
+            genpath=None,
+            apiname=apiname,
+            profile=None,
+            versions=featuresPat,
+            emitversions=featuresPat,
+            defaultExtensions=defaultExtensions,
+            addExtensions=addExtensionsPat,
+            removeExtensions=removeExtensionsPat,
+            emitExtensions=emitExtensionsPat,
+            prefixText=prefixStrings + vkPrefixStrings,
+            protectFeature=False,
+            apicall='VKAPI_ATTR ',
+            apientry='VKAPI_CALL ',
+            apientryp='VKAPI_PTR *',
+            alignFuncParam=48,
+            expandEnumerants=False,
+            helper_file_type='typemap_helper_header')
+    ]
+
+    # Options for mock ICD header
+    genOpts['function_declarations.h'] = [
+        MockICDOutputGenerator,
+        MockICDGeneratorOptions(
+            conventions=conventions,
+            filename='function_declarations.h',
+            directory=directory,
+            genpath=None,
+            apiname=apiname,
+            profile=None,
+            versions=featuresPat,
+            emitversions=featuresPat,
+            defaultExtensions=defaultExtensions,
+            addExtensions=addExtensionsPat,
+            removeExtensions=removeExtensionsPat,
+            emitExtensions=emitExtensionsPat,
+            prefixText=prefixStrings + vkPrefixStrings,
+            protectFeature=False,
+            apicall='VKAPI_ATTR ',
+            apientry='VKAPI_CALL ',
+            apientryp='VKAPI_PTR *',
+            alignFuncParam=48,
+            expandEnumerants=False,
+            helper_file_type='mock_icd_function_declaration_implementation')
+    ]
+
+    # Options for mock ICD cpp
+    genOpts['function_definitions.h'] = [
+        MockICDOutputGenerator,
+        MockICDGeneratorOptions(
+            conventions=conventions,
+            filename='function_definitions.h',
+            directory=directory,
+            genpath=None,
+            apiname=apiname,
+            profile=None,
+            versions=featuresPat,
+            emitversions=featuresPat,
+            defaultExtensions=defaultExtensions,
+            addExtensions=addExtensionsPat,
+            removeExtensions=removeExtensionsPat,
+            emitExtensions=emitExtensionsPat,
+            prefixText=prefixStrings + vkPrefixStrings,
+            protectFeature=False,
+            apicall='VKAPI_ATTR ',
+            apientry='VKAPI_CALL ',
+            apientryp='VKAPI_PTR *',
+            alignFuncParam=48,
+            expandEnumerants=False,
+            helper_file_type='mock_icd_function_definition_implementation')
+    ]
+
+    # Options for vulkaninfo.hpp
+    genOpts['vulkaninfo.hpp'] = [
+        VulkanInfoGenerator,
+        VulkanInfoGeneratorOptions(
+            conventions=conventions,
+            filename='vulkaninfo.hpp',
+            directory=directory,
+            genpath=None,
+            apiname=apiname,
+            profile=None,
+            versions=featuresPat,
+            emitversions=featuresPat,
+            defaultExtensions=defaultExtensions,
+            addExtensions=addExtensionsPat,
+            removeExtensions=removeExtensionsPat,
+            emitExtensions=emitExtensionsPat,
+            prefixText=prefixStrings + vkPrefixStrings,
+            protectFeature=False,
+            apicall='VKAPI_ATTR ',
+            apientry='VKAPI_CALL ',
+            apientryp='VKAPI_PTR *',
+            alignFuncParam=48,
+            expandEnumerants=False,
+            registryFile=args.registry)
+    ]
+
+
+# Generate a target based on the options in the matching genOpts{} object.
+# This is encapsulated in a function so it can be profiled and/or timed.
+# The args parameter is an parsed argument object containing the following
+# fields that are used:
+#   target - target to generate
+#   directory - directory to generate it in
+#   protect - True if re-inclusion wrappers should be created
+#   extensions - list of additional extensions to include in generated
+#   interfaces
+def genTarget(args):
+    global genOpts
+
+    # Create generator options with specified parameters
+    makeGenOpts(args)
+
+    if (args.target in genOpts.keys()):
+        createGenerator = genOpts[args.target][0]
+        options = genOpts[args.target][1]
+
+        if not args.quiet:
+            write('* Building', options.filename, file=sys.stderr)
+            write('* options.apiname           =', options.apiname, file=sys.stderr)
+            write('* options.versions          =', options.versions, file=sys.stderr)
+            write('* options.emitversions      =', options.emitversions, file=sys.stderr)
+            write('* options.defaultExtensions =', options.defaultExtensions, file=sys.stderr)
+            write('* options.addExtensions     =', options.addExtensions, file=sys.stderr)
+            write('* options.removeExtensions  =', options.removeExtensions, file=sys.stderr)
+            write('* options.emitExtensions    =', options.emitExtensions, file=sys.stderr)
+
+        gen = createGenerator(errFile=errWarn,
+                              warnFile=errWarn,
+                              diagFile=diag)
+        if not args.quiet:
+            write('* Generated', options.filename, file=sys.stderr)
+        return (gen, options)
+    else:
+        write('No generator options for unknown target:',
+              args.target, file=sys.stderr)
+        return none
+
+# -feature name
+# -extension name
+# For both, "name" may be a single name, or a space-separated list
+# of names, or a regular expression.
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('-api', action='store',
+                        default='vulkan',
+                        choices=['vulkan', 'vulkansc'],
+                        help='Specify API name to generate')
+    parser.add_argument('-defaultExtensions', action='store',
+                        default=None,
+                        help='Specify a single class of extensions to add to targets')
+    parser.add_argument('-directory', action='store', default='.',
+                        help='Specify where the built file is place')
+    parser.add_argument('-extension', action='append',
+                        default=[],
+                        help='Specify an extension or extensions to add to targets')
+    parser.add_argument('-removeExtensions', action='append',
+                        default=[],
+                        help='Specify an extension or extensions to remove from targets')
+    parser.add_argument('-emitExtensions', action='append',
+                        default=[],
+                        help='Specify an extension or extensions to emit in targets')
+    parser.add_argument('-feature', action='append',
+                        default=[],
+                        help='Specify a core API feature name or names to add to targets')
+    parser.add_argument('-debug', action='store_true',
+                        help='Enable debugging')
+    parser.add_argument('-dump', action='store_true',
+                        help='Enable dump to stderr')
+    parser.add_argument('-diagfile', action='store',
+                        default=None,
+                        help='Write diagnostics to specified file')
+    parser.add_argument('-errfile', action='store',
+                        default=None,
+                        help='Write errors and warnings to specified file instead of stderr')
+    parser.add_argument('-noprotect', dest='protect', action='store_false',
+                        help='Disable inclusion protection in output headers')
+    parser.add_argument('-profile', action='store_true',
+                        help='Enable profiling')
+    parser.add_argument('-registry', action='store',
+                        default='vk.xml',
+                        help='Use specified registry file instead of vk.xml')
+    parser.add_argument('-time', action='store_true',
+                        help='Enable timing')
+    parser.add_argument('-validate', action='store_true',
+                        help='Enable XML group validation')
+    parser.add_argument('-genpath', action='store', default='gen',
+                        help='Path to generated files')
+    parser.add_argument('-o', action='store', dest='directory',
+                        default='.',
+                        help='Create target and related files in specified directory')
+    parser.add_argument('target', metavar='target', nargs='?',
+                        help='Specify target')
+    parser.add_argument('-quiet', action='store_true', default=True,
+                        help='Suppress script output during normal execution.')
+    parser.add_argument('-verbose', action='store_false', dest='quiet', default=True,
+                        help='Enable script output during normal execution.')
+
+    # This argument tells us where to load the script from the Vulkan-Headers registry
+    parser.add_argument('-scripts', action='store',
+                        help='Find additional scripts in this directory')
+
+    args = parser.parse_args()
+
+    # default scripts path to be same as registry
+    if not args.scripts:
+        args.scripts = os.path.dirname(args.registry)
+
+    scripts_directory_path = os.path.dirname(os.path.abspath(__file__))
+    registry_headers_path = os.path.join(scripts_directory_path, args.scripts)
+    sys.path.insert(0, registry_headers_path)
+
+    from reg import *
+    from generator import write
+    from cgenerator import CGeneratorOptions, COutputGenerator
+
+    # Generator Modifications
+    from generators.mock_icd_generator import MockICDGeneratorOptions, MockICDOutputGenerator
+    from generators.vulkan_tools_helper_file_generator import HelperFileOutputGenerator, HelperFileOutputGeneratorOptions
+    from generators.vulkaninfo_generator import VulkanInfoGenerator, VulkanInfoGeneratorOptions
+    # Temporary workaround for vkconventions python2 compatibility
+    import abc
+    abc.ABC = abc.ABCMeta('ABC', (object,), {})
+    from vkconventions import VulkanConventions
+
+    # This splits arguments which are space-separated lists
+    args.feature = [name for arg in args.feature for name in arg.split()]
+    args.extension = [name for arg in args.extension for name in arg.split()]
+
+    # create error/warning & diagnostic files
+    if (args.errfile):
+        errWarn = open(args.errfile, 'w', encoding='utf-8')
+    else:
+        errWarn = sys.stderr
+
+    if (args.diagfile):
+        diag = open(args.diagfile, 'w', encoding='utf-8')
+    else:
+        diag = None
+
+    # Create the API generator & generator options
+    (gen, options) = genTarget(args)
+
+    # Create the registry object with the specified generator and generator
+    # options. The options are set before XML loading as they may affect it.
+    reg = Registry(gen, options)
+
+    # Parse the specified registry XML into an ElementTree object
+    startTimer(args.time)
+    tree = etree.parse(args.registry)
+    endTimer(args.time, '* Time to make ElementTree =')
+
+    # Load the XML tree into the registry object
+    startTimer(args.time)
+    reg.loadElementTree(tree)
+    endTimer(args.time, '* Time to parse ElementTree =')
+
+    if (args.validate):
+        reg.validateGroups()
+
+    if (args.dump):
+        write('* Dumping registry to regdump.txt', file=sys.stderr)
+        reg.dumpReg(filehandle = open('regdump.txt', 'w', encoding='utf-8'))
+
+    # Finally, use the output generator to create the requested target
+    if (args.debug):
+        pdb.run('reg.apiGen()')
+    else:
+        startTimer(args.time)
+        reg.apiGen()
+        endTimer(args.time, '* Time to generate ' + options.filename + ' =')
+        genTarget(args)
diff --git a/tools/Vulkan-Tools/scripts/update_deps.py b/tools/Vulkan-Tools/scripts/update_deps.py
new file mode 100755
index 00000000..7d300865
--- /dev/null
+++ b/tools/Vulkan-Tools/scripts/update_deps.py
@@ -0,0 +1,804 @@
+#!/usr/bin/env python3
+
+# Copyright 2017 The Glslang Authors. All rights reserved.
+# Copyright (c) 2018-2023 Valve Corporation
+# Copyright (c) 2018-2023 LunarG, Inc.
+# Copyright (c) 2023-2023 RasterGrid Kft.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This script was heavily leveraged from KhronosGroup/glslang
+# update_glslang_sources.py.
+"""update_deps.py
+
+Get and build dependent repositories using known-good commits.
+
+Purpose
+-------
+
+This program is intended to assist a developer of this repository
+(the "home" repository) by gathering and building the repositories that
+this home repository depend on.  It also checks out each dependent
+repository at a "known-good" commit in order to provide stability in
+the dependent repositories.
+
+Known-Good JSON Database
+------------------------
+
+This program expects to find a file named "known-good.json" in the
+same directory as the program file.  This JSON file is tailored for
+the needs of the home repository by including its dependent repositories.
+
+Program Options
+---------------
+
+See the help text (update_deps.py --help) for a complete list of options.
+
+Program Operation
+-----------------
+
+The program uses the user's current directory at the time of program
+invocation as the location for fetching and building the dependent
+repositories.  The user can override this by using the "--dir" option.
+
+For example, a directory named "build" in the repository's root directory
+is a good place to put the dependent repositories because that directory
+is not tracked by Git. (See the .gitignore file.)  The "external" directory
+may also be a suitable location.
+A user can issue:
+
+$ cd My-Repo
+$ mkdir build
+$ cd build
+$ ../scripts/update_deps.py
+
+or, to do the same thing, but using the --dir option:
+
+$ cd My-Repo
+$ mkdir build
+$ scripts/update_deps.py --dir=build
+
+With these commands, the "build" directory is considered the "top"
+directory where the program clones the dependent repositories.  The
+JSON file configures the build and install working directories to be
+within this "top" directory.
+
+Note that the "dir" option can also specify an absolute path:
+
+$ cd My-Repo
+$ scripts/update_deps.py --dir=/tmp/deps
+
+The "top" dir is then /tmp/deps (Linux filesystem example) and is
+where this program will clone and build the dependent repositories.
+
+Helper CMake Config File
+------------------------
+
+When the program finishes building the dependencies, it writes a file
+named "helper.cmake" to the "top" directory that contains CMake commands
+for setting CMake variables for locating the dependent repositories.
+This helper file can be used to set up the CMake build files for this
+"home" repository.
+
+A complete sequence might look like:
+
+$ git clone git@github.com:My-Group/My-Repo.git
+$ cd My-Repo
+$ mkdir build
+$ cd build
+$ ../scripts/update_deps.py
+$ cmake -C helper.cmake ..
+$ cmake --build .
+
+JSON File Schema
+----------------
+
+There's no formal schema for the "known-good" JSON file, but here is
+a description of its elements.  All elements are required except those
+marked as optional.  Please see the "known_good.json" file for
+examples of all of these elements.
+
+- name
+
+The name of the dependent repository.  This field can be referenced
+by the "deps.repo_name" structure to record a dependency.
+
+- api
+
+The name of the API the dependency is specific to (e.g. "vulkan").
+
+- url
+
+Specifies the URL of the repository.
+Example: https://github.com/KhronosGroup/Vulkan-Loader.git
+
+- sub_dir
+
+The directory where the program clones the repository, relative to
+the "top" directory.
+
+- build_dir
+
+The directory used to build the repository, relative to the "top"
+directory.
+
+- install_dir
+
+The directory used to store the installed build artifacts, relative
+to the "top" directory.
+
+- commit
+
+The commit used to checkout the repository.  This can be a SHA-1
+object name or a refname used with the remote name "origin".
+
+- deps (optional)
+
+An array of pairs consisting of a CMake variable name and a
+repository name to specify a dependent repo and a "link" to
+that repo's install artifacts.  For example:
+
+"deps" : [
+    {
+        "var_name" : "VULKAN_HEADERS_INSTALL_DIR",
+        "repo_name" : "Vulkan-Headers"
+    }
+]
+
+which represents that this repository depends on the Vulkan-Headers
+repository and uses the VULKAN_HEADERS_INSTALL_DIR CMake variable to
+specify the location where it expects to find the Vulkan-Headers install
+directory.
+Note that the "repo_name" element must match the "name" element of some
+other repository in the JSON file.
+
+- prebuild (optional)
+- prebuild_linux (optional)  (For Linux and MacOS)
+- prebuild_windows (optional)
+
+A list of commands to execute before building a dependent repository.
+This is useful for repositories that require the execution of some
+sort of "update" script or need to clone an auxillary repository like
+googletest.
+
+The commands listed in "prebuild" are executed first, and then the
+commands for the specific platform are executed.
+
+- custom_build (optional)
+
+A list of commands to execute as a custom build instead of using
+the built in CMake way of building. Requires "build_step" to be
+set to "custom"
+
+You can insert the following keywords into the commands listed in
+"custom_build" if they require runtime information (like whether the
+build config is "Debug" or "Release").
+
+Keywords:
+{0} reference to a dictionary of repos and their attributes
+{1} reference to the command line arguments set before start
+{2} reference to the CONFIG_MAP value of config.
+
+Example:
+{2} returns the CONFIG_MAP value of config e.g. debug -> Debug
+{1}.config returns the config variable set when you ran update_dep.py
+{0}[Vulkan-Headers][repo_root] returns the repo_root variable from
+                                   the Vulkan-Headers GoodRepo object.
+
+- cmake_options (optional)
+
+A list of options to pass to CMake during the generation phase.
+
+- ci_only (optional)
+
+A list of environment variables where one must be set to "true"
+(case-insensitive) in order for this repo to be fetched and built.
+This list can be used to specify repos that should be built only in CI.
+
+- build_step (optional)
+
+Specifies if the dependent repository should be built or not. This can
+have a value of 'build', 'custom',  or 'skip'. The dependent repositories are
+built by default.
+
+- build_platforms (optional)
+
+A list of platforms the repository will be built on.
+Legal options include:
+"windows"
+"linux"
+"darwin"
+"android"
+
+Builds on all platforms by default.
+
+Note
+----
+
+The "sub_dir", "build_dir", and "install_dir" elements are all relative
+to the effective "top" directory.  Specifying absolute paths is not
+supported.  However, the "top" directory specified with the "--dir"
+option can be a relative or absolute path.
+
+"""
+
+import argparse
+import json
+import os
+import os.path
+import subprocess
+import sys
+import platform
+import multiprocessing
+import shlex
+import shutil
+import stat
+import time
+
+KNOWN_GOOD_FILE_NAME = 'known_good.json'
+
+CONFIG_MAP = {
+    'debug': 'Debug',
+    'release': 'Release',
+    'relwithdebinfo': 'RelWithDebInfo',
+    'minsizerel': 'MinSizeRel'
+}
+
+# NOTE: CMake also uses the VERBOSE environment variable. This is intentional.
+VERBOSE = os.getenv("VERBOSE")
+
+DEVNULL = open(os.devnull, 'wb')
+
+
+def on_rm_error( func, path, exc_info):
+    """Error handler for recursively removing a directory. The
+    shutil.rmtree function can fail on Windows due to read-only files.
+    This handler will change the permissions for the file and continue.
+    """
+    os.chmod( path, stat.S_IWRITE )
+    os.unlink( path )
+
+def make_or_exist_dirs(path):
+    "Wrapper for os.makedirs that tolerates the directory already existing"
+    # Could use os.makedirs(path, exist_ok=True) if we drop python2
+    if not os.path.isdir(path):
+        os.makedirs(path)
+
+def command_output(cmd, directory):
+    # Runs a command in a directory and returns its standard output stream.
+    # Captures the standard error stream and prints it an error occurs.
+    # Raises a RuntimeError if the command fails to launch or otherwise fails.
+    if VERBOSE:
+        print('In {d}: {cmd}'.format(d=directory, cmd=cmd))
+
+    result = subprocess.run(cmd, cwd=directory, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        print(f'{result.stderr}', file=sys.stderr)
+        raise RuntimeError(f'Failed to run {cmd} in {directory}')
+
+    if VERBOSE:
+        print(result.stdout)
+    return result.stdout
+
+def run_cmake_command(cmake_cmd):
+    # NOTE: Because CMake is an exectuable that runs executables
+    # stdout/stderr are mixed together. So this combines the outputs
+    # and prints them properly in case there is a non-zero exit code.
+    result = subprocess.run(cmake_cmd, 
+        stdout = subprocess.PIPE,
+        stderr = subprocess.STDOUT,
+        text = True
+    )
+
+    if VERBOSE:
+        print(result.stdout)
+        print(f"CMake command: {cmake_cmd} ", flush=True)
+
+    if result.returncode != 0:
+        print(result.stdout, file=sys.stderr)
+        sys.exit(result.returncode)
+
+def escape(path):
+    return path.replace('\\', '/')
+
+class GoodRepo(object):
+    """Represents a repository at a known-good commit."""
+
+    def __init__(self, json, args):
+        """Initializes this good repo object.
+
+        Args:
+        'json':  A fully populated JSON object describing the repo.
+        'args':  Results from ArgumentParser
+        """
+        self._json = json
+        self._args = args
+        # Required JSON elements
+        self.name = json['name']
+        self.url = json['url']
+        self.sub_dir = json['sub_dir']
+        self.commit = json['commit']
+        # Optional JSON elements
+        self.build_dir = None
+        self.install_dir = None
+        if json.get('build_dir'):
+            self.build_dir = os.path.normpath(json['build_dir'])
+        if json.get('install_dir'):
+            self.install_dir = os.path.normpath(json['install_dir'])
+        self.deps = json['deps'] if ('deps' in json) else []
+        self.prebuild = json['prebuild'] if ('prebuild' in json) else []
+        self.prebuild_linux = json['prebuild_linux'] if (
+            'prebuild_linux' in json) else []
+        self.prebuild_windows = json['prebuild_windows'] if (
+            'prebuild_windows' in json) else []
+        self.custom_build = json['custom_build'] if ('custom_build' in json) else []
+        self.cmake_options = json['cmake_options'] if (
+            'cmake_options' in json) else []
+        self.ci_only = json['ci_only'] if ('ci_only' in json) else []
+        self.build_step = json['build_step'] if ('build_step' in json) else 'build'
+        self.build_platforms = json['build_platforms'] if ('build_platforms' in json) else []
+        self.optional = set(json.get('optional', []))
+        self.api = json['api'] if ('api' in json) else None
+        # Absolute paths for a repo's directories
+        dir_top = os.path.abspath(args.dir)
+        self.repo_dir = os.path.join(dir_top, self.sub_dir)
+        if self.build_dir:
+            self.build_dir = os.path.join(dir_top, self.build_dir)
+        if self.install_dir:
+            self.install_dir = os.path.join(dir_top, self.install_dir)
+
+        # By default the target platform is the host platform.
+        target_platform = platform.system().lower()
+        # However, we need to account for cross-compiling.
+        for cmake_var in self._args.cmake_var:
+            if "android.toolchain.cmake" in cmake_var:
+                target_platform = 'android'
+
+        self.on_build_platform = False
+        if self.build_platforms == [] or target_platform in self.build_platforms:
+            self.on_build_platform = True
+
+    def Clone(self, retries=10, retry_seconds=60):
+        if VERBOSE:
+            print('Cloning {n} into {d}'.format(n=self.name, d=self.repo_dir))
+        for retry in range(retries):
+            make_or_exist_dirs(self.repo_dir)
+            try:
+                command_output(['git', 'clone', self.url, '.'], self.repo_dir)
+                # If we get here, we didn't raise an error
+                return
+            except RuntimeError as e:
+                print("Error cloning on iteration {}/{}: {}".format(retry + 1, retries, e))
+                if retry + 1 < retries:
+                    if retry_seconds > 0:
+                        print("Waiting {} seconds before trying again".format(retry_seconds))
+                        time.sleep(retry_seconds)
+                    if os.path.isdir(self.repo_dir):
+                        print("Removing old tree {}".format(self.repo_dir))
+                        shutil.rmtree(self.repo_dir, onerror=on_rm_error)
+                    continue
+
+                # If we get here, we've exhausted our retries.
+                print("Failed to clone {} on all retries.".format(self.url))
+                raise e
+
+    def Fetch(self, retries=10, retry_seconds=60):
+        for retry in range(retries):
+            try:
+                command_output(['git', 'fetch', 'origin'], self.repo_dir)
+                # if we get here, we didn't raise an error, and we're done
+                return
+            except RuntimeError as e:
+                print("Error fetching on iteration {}/{}: {}".format(retry + 1, retries, e))
+                if retry + 1 < retries:
+                    if retry_seconds > 0:
+                        print("Waiting {} seconds before trying again".format(retry_seconds))
+                        time.sleep(retry_seconds)
+                    continue
+
+                # If we get here, we've exhausted our retries.
+                print("Failed to fetch {} on all retries.".format(self.url))
+                raise e
+
+    def Checkout(self):
+        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 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()
+        self.Fetch()
+        if len(self._args.ref):
+            command_output(['git', 'checkout', self._args.ref], self.repo_dir)
+        else:
+            command_output(['git', 'checkout', self.commit], self.repo_dir)
+
+        if VERBOSE:
+            print(command_output(['git', 'status'], self.repo_dir))
+
+    def CustomPreProcess(self, cmd_str, repo_dict):
+        return cmd_str.format(repo_dict, self._args, CONFIG_MAP[self._args.config])
+
+    def PreBuild(self):
+        """Execute any prebuild steps from the repo root"""
+        for p in self.prebuild:
+            command_output(shlex.split(p), self.repo_dir)
+        if platform.system() == 'Linux' or platform.system() == 'Darwin':
+            for p in self.prebuild_linux:
+                command_output(shlex.split(p), self.repo_dir)
+        if platform.system() == 'Windows':
+            for p in self.prebuild_windows:
+                command_output(shlex.split(p), self.repo_dir)
+
+    def CustomBuild(self, repo_dict):
+        """Execute any custom_build steps from the repo root"""
+        for p in self.custom_build:
+            cmd = self.CustomPreProcess(p, repo_dict)
+            command_output(shlex.split(cmd), self.repo_dir)
+
+    def CMakeConfig(self, repos):
+        """Build CMake command for the configuration phase and execute it"""
+        if self._args.do_clean_build:
+            if os.path.isdir(self.build_dir):
+                shutil.rmtree(self.build_dir, onerror=on_rm_error)
+        if self._args.do_clean_install:
+            if os.path.isdir(self.install_dir):
+                shutil.rmtree(self.install_dir, onerror=on_rm_error)
+
+        # Create and change to build directory
+        make_or_exist_dirs(self.build_dir)
+        os.chdir(self.build_dir)
+
+        cmake_cmd = [
+            'cmake', self.repo_dir,
+            '-DCMAKE_INSTALL_PREFIX=' + self.install_dir
+        ]
+
+        # Allow users to pass in arbitrary cache variables
+        for cmake_var in self._args.cmake_var:
+            pieces = cmake_var.split('=', 1)
+            cmake_cmd.append('-D{}={}'.format(pieces[0], pieces[1]))
+
+        # For each repo this repo depends on, generate a CMake variable
+        # definitions for "...INSTALL_DIR" that points to that dependent
+        # repo's install dir.
+        for d in self.deps:
+            dep_commit = [r for r in repos if r.name == d['repo_name']]
+            if len(dep_commit) and dep_commit[0].on_build_platform:
+                cmake_cmd.append('-D{var_name}={install_dir}'.format(
+                    var_name=d['var_name'],
+                    install_dir=dep_commit[0].install_dir))
+
+        # Add any CMake options
+        for option in self.cmake_options:
+            cmake_cmd.append(escape(option.format(**self.__dict__)))
+
+        # Set build config for single-configuration generators (this is a no-op on multi-config generators)
+        cmake_cmd.append(f'-D CMAKE_BUILD_TYPE={CONFIG_MAP[self._args.config]}')
+
+        # Use the CMake -A option to select the platform architecture
+        # without needing a Visual Studio generator.
+        if platform.system() == 'Windows' and not self._args.generator in ["Ninja", "MinGW Makefiles"]:
+            cmake_cmd.append('-A')
+            if self._args.arch.lower() == '64' or self._args.arch == 'x64' or self._args.arch == 'win64':
+                cmake_cmd.append('x64')
+            elif self._args.arch == 'arm64':
+                cmake_cmd.append('arm64')
+            else:
+                cmake_cmd.append('Win32')
+
+        # Apply a generator, if one is specified.  This can be used to supply
+        # a specific generator for the dependent repositories to match
+        # that of the main repository.
+        if self._args.generator is not None:
+            cmake_cmd.extend(['-G', self._args.generator])
+
+        # Removes warnings related to unused CLI
+        # EX: Setting CMAKE_CXX_COMPILER for a C project
+        if not VERBOSE:
+            cmake_cmd.append("--no-warn-unused-cli")
+
+        run_cmake_command(cmake_cmd)
+
+    def CMakeBuild(self):
+        """Build CMake command for the build phase and execute it"""
+        cmake_cmd = ['cmake', '--build', self.build_dir, '--target', 'install', '--config', CONFIG_MAP[self._args.config]]
+        if self._args.do_clean:
+            cmake_cmd.append('--clean-first')
+
+        # Xcode / Ninja are parallel by default.
+        if self._args.generator != "Ninja" or self._args.generator != "Xcode":
+            cmake_cmd.append('--parallel')
+            cmake_cmd.append(format(multiprocessing.cpu_count()))
+
+        run_cmake_command(cmake_cmd)
+
+    def Build(self, repos, repo_dict):
+        """Build the dependent repo and time how long it took"""
+        if VERBOSE:
+            print('Building {n} in {d}'.format(n=self.name, d=self.repo_dir))
+            print('Build dir = {b}'.format(b=self.build_dir))
+            print('Install dir = {i}\n'.format(i=self.install_dir))
+
+        start = time.time()
+
+        # Run any prebuild commands
+        self.PreBuild()
+
+        if self.build_step == 'custom':
+            self.CustomBuild(repo_dict)
+            return
+
+        # Build and execute CMake command for creating build files
+        self.CMakeConfig(repos)
+
+        # Build and execute CMake command for the build
+        self.CMakeBuild()
+
+        total_time = time.time() - start
+
+        print(f"Installed {self.name} ({self.commit}) in {total_time} seconds", flush=True)
+
+    def IsOptional(self, opts):
+        return len(self.optional.intersection(opts)) > 0
+
+def GetGoodRepos(args):
+    """Returns the latest list of GoodRepo objects.
+
+    The known-good file is expected to be in the same
+    directory as this script unless overridden by the 'known_good_dir'
+    parameter.
+    """
+    if args.known_good_dir:
+        known_good_file = os.path.join( os.path.abspath(args.known_good_dir),
+            KNOWN_GOOD_FILE_NAME)
+    else:
+        known_good_file = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), KNOWN_GOOD_FILE_NAME)
+    with open(known_good_file) as known_good:
+        return [
+            GoodRepo(repo, args)
+            for repo in json.loads(known_good.read())['repos']
+        ]
+
+
+def GetInstallNames(args):
+    """Returns the install names list.
+
+    The known-good file is expected to be in the same
+    directory as this script unless overridden by the 'known_good_dir'
+    parameter.
+    """
+    if args.known_good_dir:
+        known_good_file = os.path.join(os.path.abspath(args.known_good_dir),
+            KNOWN_GOOD_FILE_NAME)
+    else:
+        known_good_file = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), KNOWN_GOOD_FILE_NAME)
+    with open(known_good_file) as known_good:
+        install_info = json.loads(known_good.read())
+        if install_info.get('install_names'):
+            return install_info['install_names']
+        else:
+            return None
+
+
+def CreateHelper(args, repos, filename):
+    """Create a CMake config helper file.
+
+    The helper file is intended to be used with 'cmake -C <file>'
+    to build this home repo using the dependencies built by this script.
+
+    The install_names dictionary represents the CMake variables used by the
+    home repo to locate the install dirs of the dependent repos.
+    This information is baked into the CMake files of the home repo and so
+    this dictionary is kept with the repo via the json file.
+    """
+    install_names = GetInstallNames(args)
+    with open(filename, 'w') as helper_file:
+        for repo in repos:
+            # If the repo has an API tag and that does not match
+            # the target API then skip it
+            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'
+                                  .format(
+                                      var=install_names[repo.name],
+                                      dir=escape(repo.install_dir)))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Get and build dependent repos at known-good commits')
+    parser.add_argument(
+        '--known_good_dir',
+        dest='known_good_dir',
+        help="Specify directory for known_good.json file.")
+    parser.add_argument(
+        '--dir',
+        dest='dir',
+        default='.',
+        help="Set target directory for repository roots. Default is \'.\'.")
+    parser.add_argument(
+        '--ref',
+        dest='ref',
+        default='',
+        help="Override 'commit' with git reference. E.g., 'origin/main'")
+    parser.add_argument(
+        '--no-build',
+        dest='do_build',
+        action='store_false',
+        help=
+        "Clone/update repositories and generate build files without performing compilation",
+        default=True)
+    parser.add_argument(
+        '--clean',
+        dest='do_clean',
+        action='store_true',
+        help="Clean files generated by compiler and linker before building",
+        default=False)
+    parser.add_argument(
+        '--clean-repo',
+        dest='do_clean_repo',
+        action='store_true',
+        help="Delete repository directory before building",
+        default=False)
+    parser.add_argument(
+        '--clean-build',
+        dest='do_clean_build',
+        action='store_true',
+        help="Delete build directory before building",
+        default=False)
+    parser.add_argument(
+        '--clean-install',
+        dest='do_clean_install',
+        action='store_true',
+        help="Delete install directory before building",
+        default=False)
+    parser.add_argument(
+        '--skip-existing-install',
+        dest='skip_existing_install',
+        action='store_true',
+        help="Skip build if install directory exists",
+        default=False)
+    parser.add_argument(
+        '--arch',
+        dest='arch',
+        choices=['32', '64', 'x86', 'x64', 'win32', 'win64', 'arm64'],
+        type=str.lower,
+        help="Set build files architecture (Visual Studio Generator Only)",
+        default='64')
+    parser.add_argument(
+        '--config',
+        dest='config',
+        choices=['debug', 'release', 'relwithdebinfo', 'minsizerel'],
+        type=str.lower,
+        help="Set build files configuration",
+        default='debug')
+    parser.add_argument(
+        '--api',
+        dest='api',
+        default='vulkan',
+        choices=['vulkan'],
+        help="Target API")
+    parser.add_argument(
+        '--generator',
+        dest='generator',
+        help="Set the CMake generator",
+        default=None)
+    parser.add_argument(
+        '--optional',
+        dest='optional',
+        type=lambda a: set(a.lower().split(',')),
+        help="Comma-separated list of 'optional' resources that may be skipped. Only 'tests' is currently supported as 'optional'",
+        default=set())
+    parser.add_argument(
+        '--cmake_var',
+        dest='cmake_var',
+        action='append',
+        metavar='VAR[=VALUE]',
+        help="Add CMake command line option -D'VAR'='VALUE' to the CMake generation command line; may be used multiple times",
+        default=[])
+
+    args = parser.parse_args()
+    save_cwd = os.getcwd()
+
+    # Create working "top" directory if needed
+    make_or_exist_dirs(args.dir)
+    abs_top_dir = os.path.abspath(args.dir)
+
+    repos = GetGoodRepos(args)
+    repo_dict = {}
+
+    print('Starting builds in {d}'.format(d=abs_top_dir))
+    for repo in repos:
+        # If the repo has an API tag and that does not match
+        # the target API then skip it
+        if repo.api is not None and repo.api != args.api:
+            continue
+
+        # If the repo has a platform whitelist, skip the repo
+        # unless we are building on a whitelisted platform.
+        if not repo.on_build_platform:
+            continue
+
+        # Skip building the repo if its install directory already exists
+        # and requested via an option.  This is useful for cases where the
+        # install directory is restored from a cache that is known to be up
+        # to date.
+        if args.skip_existing_install and os.path.isdir(repo.install_dir):
+            print('Skipping build for repo {n} due to existing install directory'.format(n=repo.name))
+            continue
+
+        # Skip test-only repos if the --tests option was not passed in
+        if repo.IsOptional(args.optional):
+            continue
+
+        field_list = ('url',
+                      'sub_dir',
+                      'commit',
+                      'build_dir',
+                      'install_dir',
+                      'deps',
+                      'prebuild',
+                      'prebuild_linux',
+                      'prebuild_windows',
+                      'custom_build',
+                      'cmake_options',
+                      'ci_only',
+                      'build_step',
+                      'build_platforms',
+                      'repo_dir',
+                      'on_build_platform')
+        repo_dict[repo.name] = {field: getattr(repo, field) for field in field_list}
+
+        # If the repo has a CI whitelist, skip the repo unless
+        # one of the CI's environment variable is set to true.
+        if len(repo.ci_only):
+            do_build = False
+            for env in repo.ci_only:
+                if env not in os.environ:
+                    continue
+                if os.environ[env].lower() == 'true':
+                    do_build = True
+                    break
+            if not do_build:
+                continue
+
+        # Clone/update the repository
+        repo.Checkout()
+
+        # Build the repository
+        if args.do_build and repo.build_step != 'skip':
+            repo.Build(repos, repo_dict)
+
+    # Need to restore original cwd in order for CreateHelper to find json file
+    os.chdir(save_cwd)
+    CreateHelper(args, repos, os.path.join(abs_top_dir, 'helper.cmake'))
+
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()