From 0b1a317983b93bb839f3fd61aca84b8b4adb1b0a Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Sat, 23 Nov 2024 11:37:45 -0500 Subject: [PATCH 01/12] Implement Automated Test App testing Add Mock ICD Add Headless mode to Test Apps Add Test Runner Add CICD scripts for running tests in Github Actions --- .github/workflows/ci_build.yml | 165 +- CMakeLists.txt | 235 +- cmake/FindGoogleTest.cmake | 8 + cmake/FindSDL3.cmake | 3 + layer/json/VkLayer_gfxreconstruct.json.in | 3 + test/CMakeLists.txt | 43 +- test/icd/CMakeLists.txt | 132 + test/icd/README.md | 80 + test/icd/VkICD_mock_icd.def | 37 + test/icd/VkICD_mock_icd.json.in | 7 + test/icd/generated/.clang-format | 5 + test/icd/generated/function_declarations.h | 5436 +++++++++++ test/icd/generated/function_definitions.h | 8018 +++++++++++++++ test/icd/generated/vk_typemap_helper.h | 8678 +++++++++++++++++ test/icd/mock_icd.cpp | 186 + test/icd/mock_icd.h | 270 + test/icd/mock_icd_test_config.h | 28 + test/known_good/.gitignore | 1 + test/known_good/multisample-depth.gfxr | Bin 0 -> 28209 bytes test/known_good/multisample-depth_macos.gfxr | Bin 0 -> 28152 bytes test/known_good/pipeline-binaries.gfxr | Bin 0 -> 8967 bytes test/known_good/pipeline-binaries_macos.gfxr | Bin 0 -> 8836 bytes test/known_good/shader-objects.gfxr | Bin 0 -> 56184 bytes test/known_good/shader-objects_macos.gfxr | Bin 0 -> 56335 bytes test/known_good/triangle.gfxr | Bin 0 -> 25906 bytes test/known_good/triangle_macos.gfxr | Bin 0 -> 25844 bytes test/run-tests.ps1 | 26 + test/run-tests.sh | 16 + test/run-tests_macos.sh | 16 + test/test_apps/CMakeLists.txt | 3 + test/test_apps/common/CMakeLists.txt | 4 + .../common/CurrentBuildVulkanVersion.cmake | 4 +- test/test_apps/common/test_app_base.cpp | 189 +- test/test_apps/common/test_app_base.h | 37 +- test/test_apps/host-image-copy/CMakeLists.txt | 42 +- test/test_apps/host-image-copy/app.cpp | 29 +- .../multisample-depth/CMakeLists.txt | 45 +- test/test_apps/multisample-depth/app.cpp | 34 +- .../pipeline-binaries/CMakeLists.txt | 46 +- test/test_apps/pipeline-binaries/app.cpp | 39 +- test/test_apps/shader-objects/CMakeLists.txt | 46 +- test/test_apps/shader-objects/app.cpp | 47 +- test/test_apps/triangle/CMakeLists.txt | 46 +- test/test_apps/triangle/app.cpp | 30 +- test/test_cases/multisample-depth.cpp | 22 + test/test_cases/pipeline-binaries.cpp | 22 + test/test_cases/shader-objects.cpp | 22 + test/test_cases/triangle.cpp | 22 + test/verify-gfxr.cpp | 130 + test/verify-gfxr.h | 22 + 50 files changed, 23771 insertions(+), 503 deletions(-) create mode 100644 cmake/FindGoogleTest.cmake create mode 100644 test/icd/CMakeLists.txt create mode 100644 test/icd/README.md create mode 100644 test/icd/VkICD_mock_icd.def create mode 100644 test/icd/VkICD_mock_icd.json.in create mode 100644 test/icd/generated/.clang-format create mode 100644 test/icd/generated/function_declarations.h create mode 100644 test/icd/generated/function_definitions.h create mode 100644 test/icd/generated/vk_typemap_helper.h create mode 100644 test/icd/mock_icd.cpp create mode 100644 test/icd/mock_icd.h create mode 100644 test/icd/mock_icd_test_config.h create mode 100644 test/known_good/.gitignore create mode 100644 test/known_good/multisample-depth.gfxr create mode 100644 test/known_good/multisample-depth_macos.gfxr create mode 100644 test/known_good/pipeline-binaries.gfxr create mode 100644 test/known_good/pipeline-binaries_macos.gfxr create mode 100644 test/known_good/shader-objects.gfxr create mode 100644 test/known_good/shader-objects_macos.gfxr create mode 100644 test/known_good/triangle.gfxr create mode 100644 test/known_good/triangle_macos.gfxr create mode 100644 test/run-tests.ps1 create mode 100644 test/run-tests.sh create mode 100644 test/run-tests_macos.sh create mode 100644 test/test_apps/common/CMakeLists.txt create mode 100644 test/test_cases/multisample-depth.cpp create mode 100644 test/test_cases/pipeline-binaries.cpp create mode 100644 test/test_cases/shader-objects.cpp create mode 100644 test/test_cases/triangle.cpp create mode 100644 test/verify-gfxr.cpp create mode 100644 test/verify-gfxr.h diff --git a/.github/workflows/ci_build.yml b/.github/workflows/ci_build.yml index 3d4f76f7a7..c3aa34548d 100644 --- a/.github/workflows/ci_build.yml +++ b/.github/workflows/ci_build.yml @@ -15,18 +15,20 @@ jobs: fail-fast: false matrix: config: - - { + - { name: "Ubuntu GCC Release", os: ubuntu-latest, artifact: "gfxreconstruct-dev-ubuntu-gcc-release", + test_failure_artifact: "gfxreconstruct-dev-test-failure-ubuntu-gcc-release", type: "release", build_dir: "build", cc: "gcc", cxx: "g++" } - - { + - { name: "Ubuntu GCC Debug", os: ubuntu-latest, artifact: "gfxreconstruct-dev-ubuntu-gcc-debug", + test_failure_artifact: "gfxreconstruct-dev-test-failure-ubuntu-gcc-debug", type: "debug", build_dir: "dbuild", cc: "gcc", cxx: "g++" @@ -55,6 +57,20 @@ jobs: else python3 scripts/build.py --config ${{ matrix.config.type }} --skip-check-code-style --parallel 0 --test-apps fi + - name: Run test app test cases + id: test_apps + run: | + cd ${{matrix.config.build_dir}}/linux/x64/output/test + sudo useradd test + sudo usermod -a -G docker test + chmod -R g+w . + sudo -n -u test ./run-tests.sh + - name: Upload test failure artifacts + uses: actions/upload-artifact@v4 + if: ${{ failure() && steps.test_apps.conclusion == 'failure' }} + with: + name: ${{ matrix.config.test_failure_artifact }} + path: ${{matrix.config.build_dir}}/linux/x64/output/test - name: Prepare artifacts run: | cp LICENSE.txt ${{ matrix.config.build_dir }}/linux/x64/output/bin/ @@ -77,18 +93,20 @@ jobs: fail-fast: false matrix: config: - - { + - { name: "Windows MSVC Release", os: windows-latest, artifact: "gfxreconstruct-dev-windows-msvc-release", + test_failure_artifact: "gfxreconstruct-dev-test-failure-windows-msvc-release", type: "release", build_dir: "build", cc: "cl", cxx: "cl" } - - { + - { name: "Windows MSVC Debug", os: windows-latest, artifact: "gfxreconstruct-dev-windows-msvc-debug", + test_failure_artifact: "gfxreconstruct-dev-test-failure-windows-msvc-debug", type: "debug", build_dir: "dbuild", cc: "cl", cxx: "cl" @@ -120,6 +138,20 @@ jobs: - name: Run build script run: | python scripts\build.py --skip-check-code-style --config ${{ matrix.config.type }} --parallel 0 --test-apps + - name: Run test app test cases + id: test_apps + run: | + curl.exe -o vulkan-sdk.zip https://sdk.lunarg.com/sdk/download/1.3.296.0/windows/VulkanRT-1.3.296.0-Components.zip + Expand-Archive vulkan-sdk.zip -DestinationPath $pwd\vulkan-sdk + $env:Path += ";$pwd\vulkan-sdk\VulkanRT-1.3.296.0-Components\x64" + cd ${{matrix.config.build_dir}}\windows\x64\output\test + ./run-tests.ps1 + - name: Upload test failure artifacts + uses: actions/upload-artifact@v4 + if: ${{ failure() && steps.test_apps.conclusion == 'failure' }} + with: + name: ${{ matrix.config.test_failure_artifact }} + path: ${{matrix.config.build_dir}}\windows\x64\output\test - name: Prepare artifacts run: | copy LICENSE.txt ${{ matrix.config.build_dir }}\windows\x64\output\bin\ @@ -141,17 +173,19 @@ jobs: fail-fast: false matrix: config: - - { + - { name: "macOS Release", os: macos-latest, artifact: "gfxreconstruct-dev-macOS-release", + test_failure_artifact: "gfxreconstruct-dev-test-failure-macOS-release", type: "release", build_dir: "build" } - - { + - { name: "macOS Debug", os: macos-latest, artifact: "gfxreconstruct-dev-macOS-debug", + test_failure_artifact: "gfxreconstruct-dev-test-failure-macOS-debug", type: "debug", build_dir: "dbuild" } @@ -172,6 +206,31 @@ jobs: - name: Run build script run: | python3 scripts/build.py --skip-check-code-style --config ${{ matrix.config.type }} --cmake-extra "CMAKE_PREFIX_PATH=$HOME/deps" --cmake-extra CMAKE_OSX_DEPLOYMENT_TARGET=11.0 --parallel 0 --test-apps + - name: Run test app test cases + id: test_apps + run: | + WORKING_PATH="$(pwd)/${{matrix.config.build_dir}}/darwin/universal/output/test" + cd $WORKING_PATH + curl https://sdk.lunarg.com/sdk/download/1.4.304.0/mac/vulkansdk-macos-1.4.304.0.zip -o ./vulkan-sdk.zip + unzip ./vulkan-sdk.zip -d ./vulkan-sdk + sudo ./vulkan-sdk/InstallVulkan.app/Contents/MacOS/InstallVulkan --root $(pwd)/VulkanSDK/1.3.304.0 --accept-licenses --default-answer --confirm-command install + sudo dscl . -create /Users/test + sudo dscl . append /Groups/staff GroupMembership test + sudo dscl . -create /Users/test UserShell /bin/bash + sudo dscl . -create /Users/test RealName "Test" + sudo dscl . -create /Users/test UniqueID "1001" + sudo dscl . -create /Users/test PrimaryGroupID 80 + sudo dscl . -create /Users/test NFSHomeDirectory /Users/test + sudo mkdir -p /Users/test + sudo chown -R test:staff /Users/test + sudo chmod -R g+w . + sudo su - test -c "cd $WORKING_PATH && VULKAN_LIBRARY_PATH=$(pwd)/VulkanSDK/1.3.304.0/macOS/lib/libvulkan.dylib ./run-tests_macos.sh" + - name: Upload test failure artifacts + uses: actions/upload-artifact@v4 + if: ${{ failure() && steps.test_apps.conclusion == 'failure' }} + with: + name: ${{ matrix.config.test_failure_artifact }} + path: ${{matrix.config.build_dir}}/darwin/universal/output/test - name: Prepare artifacts run: | cp LICENSE.txt ${{ matrix.config.build_dir }}/darwin/universal/output/bin/ @@ -198,58 +257,60 @@ jobs: fail-fast: false matrix: config: - - { + - { name: "Android Debug", os: ubuntu-latest, type: "debug", - artifact: "gfxreconstruct-dev-android-debug" + artifact: "gfxreconstruct-dev-android-debug", + test_failure_artifact: "gfxreconstruct-dev-test-failure-android-debug" } - - { + - { name: "Android Release", os: ubuntu-latest, type: "release", - artifact: "gfxreconstruct-dev-android-release" + artifact: "gfxreconstruct-dev-android-release", + test_failure_artifact: "gfxreconstruct-dev-test-failure-android-release" } steps: - - name: Clone repository - uses: actions/checkout@v4 - with: - submodules: 'recursive' - - name: Update submodules - run: | - git submodule update --init - - name: Set up Java - uses: "actions/setup-java@v4" - with: - java-version: 17 - distribution: "temurin" - - name: Gradle build - run: | - cd android - if [ "${{ matrix.config.type }}" == "release" ] - then - sh gradlew assembleRelease -Parm64-v8a - else - sh gradlew assembleDebug -Parm64-v8a - fi - - name: Prepare artifacts - run: | - mkdir gfxreconstruct-dev - mkdir gfxreconstruct-dev/layer - mkdir gfxreconstruct-dev/tools - cp LICENSE.txt gfxreconstruct-dev/ - cp LICENSE_ThirdParty.txt gfxreconstruct-dev/ - cp USAGE_android.md gfxreconstruct-dev/ - cp layer/vk_layer_settings.txt gfxreconstruct-dev/ - if [ "${{ matrix.config.type }}" == "release" ] - then - cp -r android/layer/build/intermediates/cxx/RelWithDebInfo/*/obj/arm64-v8a gfxreconstruct-dev/layer/ - else - cp android/tools/replay/build/outputs/apk/debug/replay-debug.apk gfxreconstruct-dev/tools/ - fi - cp android/scripts/gfxrecon.py gfxreconstruct-dev/tools/ - - name: Upload artifacts - uses: actions/upload-artifact@v4 - with: - name: ${{ matrix.config.artifact }} - path: ./gfxreconstruct-dev + - name: Clone repository + uses: actions/checkout@v4 + with: + submodules: 'recursive' + - name: Update submodules + run: | + git submodule update --init + - name: Set up Java + uses: "actions/setup-java@v4" + with: + java-version: 17 + distribution: "temurin" + - name: Gradle build + run: | + cd android + if [ "${{ matrix.config.type }}" == "release" ] + then + sh gradlew assembleRelease -Parm64-v8a + else + sh gradlew assembleDebug -Parm64-v8a + fi + - name: Prepare artifacts + run: | + mkdir gfxreconstruct-dev + mkdir gfxreconstruct-dev/layer + mkdir gfxreconstruct-dev/tools + cp LICENSE.txt gfxreconstruct-dev/ + cp LICENSE_ThirdParty.txt gfxreconstruct-dev/ + cp USAGE_android.md gfxreconstruct-dev/ + cp layer/vk_layer_settings.txt gfxreconstruct-dev/ + if [ "${{ matrix.config.type }}" == "release" ] + then + cp -r android/layer/build/intermediates/cxx/RelWithDebInfo/*/obj/arm64-v8a gfxreconstruct-dev/layer/ + else + cp android/tools/replay/build/outputs/apk/debug/replay-debug.apk gfxreconstruct-dev/tools/ + fi + cp android/scripts/gfxrecon.py gfxreconstruct-dev/tools/ + - name: Upload artifacts + uses: actions/upload-artifact@v4 + with: + name: ${{ matrix.config.artifact }} + path: ./gfxreconstruct-dev diff --git a/CMakeLists.txt b/CMakeLists.txt index 94a0bdf83e..df65f518e5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -60,7 +60,7 @@ option(BUILD_STATIC "Build static binaries for HPC clusters (will not build the if (NOT DEFINED HEADLESS) set(HEADLESS TRUE) -endif() +endif () include(GetGitRevisionDescription) get_git_head_revision(GIT_REFSPEC GIT_SHA1) @@ -75,38 +75,38 @@ if (GIT_REFSPEC) if (GIT_IS_MASTER OR GIT_IS_SDK) if (GIT_TAG) set(GIT_BRANCH ${GIT_TAG}) - else() + else () set(GIT_BRANCH "") - endif() - if(NOT DEFINED GFXRECON_PROJECT_VERSION_DESIGNATION) + endif () + if (NOT DEFINED GFXRECON_PROJECT_VERSION_DESIGNATION) set(GFXRECON_PROJECT_VERSION_DESIGNATION "") - endif() - elseif(NOT DEFINED GFXRECON_PROJECT_VERSION_DESIGNATION) + endif () + elseif (NOT DEFINED GFXRECON_PROJECT_VERSION_DESIGNATION) set(GFXRECON_PROJECT_VERSION_DESIGNATION "-dev") - endif() -elseif(GIT_TAG) + endif () +elseif (GIT_TAG) string(REGEX MATCH "^v[0-9]+\.[0-9]+\.[0-9]+$" GIT_IS_VERSION_RELEASE_TAG ${GIT_TAG}) if (GIT_IS_VERSION_RELEASE_TAG) set(GIT_BRANCH ${GIT_TAG}) set(GFXRECON_PROJECT_VERSION_DESIGNATION "") - endif() -elseif(NOT DEFINED GFXRECON_PROJECT_VERSION_DESIGNATION) + endif () +elseif (NOT DEFINED GFXRECON_PROJECT_VERSION_DESIGNATION) set(GFXRECON_PROJECT_VERSION_DESIGNATION "-unknown") -endif() +endif () if (GIT_SHA1) string(SUBSTRING ${GIT_SHA1} 0 7 GFXRECON_PROJECT_VERSION_SHA1) if (GIT_BRANCH) string(CONCAT GFXRECON_PROJECT_VERSION_SHA1 ${GIT_BRANCH} ":" ${GFXRECON_PROJECT_VERSION_SHA1}) - endif() + endif () git_local_changes(GIT_LOCAL_STATE) string(COMPARE EQUAL ${GIT_LOCAL_STATE} "DIRTY" GIT_DIRTY) if (GIT_DIRTY) string(CONCAT GFXRECON_PROJECT_VERSION_SHA1 ${GFXRECON_PROJECT_VERSION_SHA1} "*") - endif() -endif() + endif () +endif () # Adds all the configure time information into project_version_temp.h.in configure_file("${CMAKE_SOURCE_DIR}/project_version.h.in" "${CMAKE_BINARY_DIR}/project_version_temp.h.in") @@ -133,15 +133,15 @@ macro(common_build_directives TARGET) endmacro() option(GFXRECON_ENABLE_RELEASE_ASSERTS "Enable release builds to output failed conditions caught by GFXRECON_ASSERT macro." OFF) -if(${GFXRECON_ENABLE_RELEASE_ASSERTS}) +if (${GFXRECON_ENABLE_RELEASE_ASSERTS}) add_definitions(-DGFXRECON_ENABLE_RELEASE_ASSERTS) -endif() +endif () option(GFXRECON_TOCPP_SUPPORT "Build ToCpp export tool as part of GFXReconstruct builds." TRUE) option(GFXRECON_INCLUDE_TEST_APPS "Build and install test apps" OFF) -if(MSVC) +if (MSVC) # The host toolchain architecture (i.e. are the compiler and other tools compiled to ARM/Intel 32bit/64bit binaries): message(STATUS "CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE: " ${CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE}) @@ -152,24 +152,24 @@ if(MSVC) message(STATUS "CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION: " ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}) set(GFXR_ARM_WINDOWS_BUILD FALSE) - if(CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64") + if (CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64") set(GFXR_ARM_WINDOWS_BUILD TRUE) - endif() + endif () # Default to using the precompiled LZ4 and ZLIB binaries for VisualStudio builds. - set (PRECOMPILED_ARCH "64") - if(CMAKE_SIZEOF_VOID_P EQUAL 4) - set (PRECOMPILED_ARCH "32") - endif(CMAKE_SIZEOF_VOID_P EQUAL 4) + set(PRECOMPILED_ARCH "64") + if (CMAKE_SIZEOF_VOID_P EQUAL 4) + set(PRECOMPILED_ARCH "32") + endif (CMAKE_SIZEOF_VOID_P EQUAL 4) - if(GFXR_ARM_WINDOWS_BUILD) - set (PRECOMPILED_ARCH "64-arm") - endif() + if (GFXR_ARM_WINDOWS_BUILD) + set(PRECOMPILED_ARCH "64-arm") + endif () set(CMAKE_PREFIX_PATH - ${CMAKE_PREFIX_PATH} - "${CMAKE_SOURCE_DIR}/external/precompiled/win${PRECOMPILED_ARCH}" - "${CMAKE_SOURCE_DIR}/external/precompiled/win${PRECOMPILED_ARCH}") + ${CMAKE_PREFIX_PATH} + "${CMAKE_SOURCE_DIR}/external/precompiled/win${PRECOMPILED_ARCH}" + "${CMAKE_SOURCE_DIR}/external/precompiled/win${PRECOMPILED_ARCH}") # Enable LARGEADDRESSAWARE to increase memory address space for 32-bit executables set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LARGEADDRESSAWARE") @@ -179,11 +179,11 @@ if(MSVC) # Add option to enable/disable launcher and interceptor. option(BUILD_LAUNCHER_AND_INTERCEPTOR "Build launcher and interceptor" OFF) - + # Enable STL locks to work after building capture libs with certain versions of VS add_definitions(-D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR) - if(${D3D12_SUPPORT}) + if (${D3D12_SUPPORT}) set(D3D12_INCLUDE_DIRECTORIES "${CMAKE_SOURCE_DIR}/external/AgilitySDK/inc") add_definitions(-DD3D12_SUPPORT) @@ -191,26 +191,26 @@ if(MSVC) set(EXPECTED_WIN_SDK_VER "10.0.20348.0") if (NOT ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION} STREQUAL ${EXPECTED_WIN_SDK_VER}) message(WARNING - "D3D12 support is authored against Windows SDK ${EXPECTED_WIN_SDK_VER}. Windows SDK version " - "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION} may not be compatible. If you encounter build errors, " - "set D3D12_SUPPORT=OFF or configure the build with the recommended Windows SDK version. See BUILD.md " - "for more information.") - endif() - + "D3D12 support is authored against Windows SDK ${EXPECTED_WIN_SDK_VER}. Windows SDK version " + "${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION} may not be compatible. If you encounter build errors, " + "set D3D12_SUPPORT=OFF or configure the build with the recommended Windows SDK version. See BUILD.md " + "for more information.") + endif () + find_package(DXC) if (DXC_FOUND) set(D3D12_INCLUDE_DIRECTORIES ${D3D12_INCLUDE_DIRECTORIES} ${DXC_INCLUDE_DIR}) add_definitions(-DGFXRECON_DXC_SUPPORT) - endif() + endif () - else() + else () set(BUILD_LAUNCHER_AND_INTERCEPTOR OFF) - endif() + endif () - if(${BUILD_LAUNCHER_AND_INTERCEPTOR}) + if (${BUILD_LAUNCHER_AND_INTERCEPTOR}) add_definitions(-DBUILD_LAUNCHER_AND_INTERCEPTOR) - endif() + endif () # Add option to enable/disable AGS support. option(GFXRECON_AGS_SUPPORT "Build with AGS support enabled. Ignored if D3D12_SUPPORT=OFF." ON) @@ -227,128 +227,128 @@ if(MSVC) # The value for option GFXRECON_AGS_SUPPORT gets cached so use a non-cached variable # to determine the final result. set(GFXRECON_AGS_SUPPORT_FINAL ON) - else() + else () message(WARNING "GFXRECON_AGS_SUPPORT was requested but the required dependencies were not found. " "AGS support will be disabled.") - endif() # AGS_FOUND - else() + endif () # AGS_FOUND + else () message(WARNING "GFXRECON_AGS_SUPPORT was requested but is not supported. An x64 build is required. " "AGS support will be disabled.") - endif() # CMAKE_SIZEOF_VOID_P EQUAL 8 - endif() # GFXRECON_AGS_SUPPORT - endif() # D3D12_SUPPORT + endif () # CMAKE_SIZEOF_VOID_P EQUAL 8 + endif () # GFXRECON_AGS_SUPPORT + endif () # D3D12_SUPPORT -else(MSVC) +else (MSVC) # Turn off D3D12 support for non MSVC builds. set(D3D12_SUPPORT OFF) set(BUILD_LAUNCHER_AND_INTERCEPTOR OFF) - if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") + if (CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") set(CMAKE_PREFIX_PATH - ${CMAKE_PREFIX_PATH} - "${CMAKE_SOURCE_DIR}/external/precompiled/linux/lib/arm64-v8a") - elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm") + ${CMAKE_PREFIX_PATH} + "${CMAKE_SOURCE_DIR}/external/precompiled/linux/lib/arm64-v8a") + elseif (CMAKE_SYSTEM_PROCESSOR STREQUAL "arm") set(CMAKE_PREFIX_PATH - ${CMAKE_PREFIX_PATH} - "${CMAKE_SOURCE_DIR}/external/precompiled/linux/lib/arm") - endif() -endif(MSVC) + ${CMAKE_PREFIX_PATH} + "${CMAKE_SOURCE_DIR}/external/precompiled/linux/lib/arm") + endif () +endif (MSVC) -if(APPLE) +if (APPLE) add_link_options(-Wl,-dead_strip -Wl,-dead_strip_dylibs) set(CMAKE_PREFIX_PATH - "${CMAKE_SOURCE_DIR}/external/precompiled/macos" - ${CMAKE_PREFIX_PATH}) -endif() + "${CMAKE_SOURCE_DIR}/external/precompiled/macos" + ${CMAKE_PREFIX_PATH}) +endif () # GFXReconstruct provided find modules -if(WIN32) -find_package(Detours) -endif() # WIN32 +if (WIN32) + find_package(Detours) +endif () # WIN32 option(LZ4_OPTIONAL "Allow building without LZ4-compression" OFF) find_package(LZ4) -if(NOT LZ4_FOUND) - if(LZ4_OPTIONAL) +if (NOT LZ4_FOUND) + if (LZ4_OPTIONAL) message(STATUS "LZ4 library not found, but declared optional. LZ4 support is disabled.") - else() + else () message(FATAL_ERROR "LZ4 library not found. Please install LZ4 or allow building without it by setting LZ4_OPTIONAL to ON.") - endif()# LZ4_OPTIONAL -endif()# NOT LZ4_FOUND + endif ()# LZ4_OPTIONAL +endif ()# NOT LZ4_FOUND find_package(ZSTD) -if(MSVC) -find_package(jsoncpp) -endif() # MSVC +if (MSVC) + find_package(jsoncpp) +endif () # MSVC -if(UNIX AND NOT APPLE) +if (UNIX AND NOT APPLE) option(BUILD_WSI_XCB_SUPPORT "Build XCB WSI support" ON) option(BUILD_WSI_WAYLAND_SUPPORT "Build Wayland WSI support" ON) option(BUILD_WSI_DISPLAY_SUPPORT "Build direct-to-display swapchain support" ON) - if(BUILD_WSI_XCB_SUPPORT) + if (BUILD_WSI_XCB_SUPPORT) find_package(XCB) - endif() + endif () - if(BUILD_WSI_WAYLAND_SUPPORT) + if (BUILD_WSI_WAYLAND_SUPPORT) find_package(WAYLAND) - endif() -endif(UNIX AND NOT APPLE) + endif () +endif (UNIX AND NOT APPLE) # CMake provided find modules -if(BUILD_STATIC) +if (BUILD_STATIC) find_library(ZLIB NAMES libz.a REQUIRED PATH_SUFFIXES lib lib/x86_64-linux-gnu lib64) -else() +else () find_package(ZLIB) -endif() -if(UNIX AND NOT APPLE) +endif () +if (UNIX AND NOT APPLE) option(BUILD_WSI_XLIB_SUPPORT "Build Xlib WSI support" ON) - if(BUILD_WSI_XLIB_SUPPORT) + if (BUILD_WSI_XLIB_SUPPORT) find_package(X11) - endif() -endif(UNIX AND NOT APPLE) + endif () +endif (UNIX AND NOT APPLE) add_library(windows_specific INTERFACE) target_compile_definitions(windows_specific INTERFACE - WIN32_LEAN_AND_MEAN - NOMINMAX - VK_USE_PLATFORM_WIN32_KHR - $<$:VK_USE_PLATFORM_HEADLESS> - $<$:"GFXR_INTERCEPTOR_PATH=\"$\""> - $<$:"GFXR_D3D12_CAPTURE_PATH=\"$\""> - $<$:"GFXR_D3D12_PATH=\"$\""> - $<$:"GFXR_DXGI_PATH=\"$\"">) + WIN32_LEAN_AND_MEAN + NOMINMAX + VK_USE_PLATFORM_WIN32_KHR + $<$:VK_USE_PLATFORM_HEADLESS> + $<$:"GFXR_INTERCEPTOR_PATH=\"$\""> + $<$:"GFXR_D3D12_CAPTURE_PATH=\"$\""> + $<$:"GFXR_D3D12_PATH=\"$\""> + $<$:"GFXR_DXGI_PATH=\"$\"">) add_library(linux_specific INTERFACE) target_compile_definitions(linux_specific INTERFACE _FILE_OFFSET_BITS=64 PAGE_GUARD_ENABLE_UCONTEXT_WRITE_DETECTION - $<$:VK_USE_PLATFORM_XLIB_KHR> - $<$:VK_USE_PLATFORM_XLIB_XRANDR_EXT> - $<$:VK_USE_PLATFORM_XCB_KHR> - $<$:VK_USE_PLATFORM_WAYLAND_KHR> - $<$:VK_USE_PLATFORM_DISPLAY_KHR> - $<$:VK_USE_PLATFORM_HEADLESS>) + $<$:VK_USE_PLATFORM_XLIB_KHR> + $<$:VK_USE_PLATFORM_XLIB_XRANDR_EXT> + $<$:VK_USE_PLATFORM_XCB_KHR> + $<$:VK_USE_PLATFORM_WAYLAND_KHR> + $<$:VK_USE_PLATFORM_DISPLAY_KHR> + $<$:VK_USE_PLATFORM_HEADLESS>) add_library(macos_specific INTERFACE) target_compile_definitions(macos_specific INTERFACE - VK_USE_PLATFORM_METAL_EXT - $<$:VK_USE_PLATFORM_HEADLESS>) + VK_USE_PLATFORM_METAL_EXT + $<$:VK_USE_PLATFORM_HEADLESS>) add_library(platform_specific INTERFACE) target_link_libraries(platform_specific INTERFACE - $<$:windows_specific> - $<$:macos_specific> - $<$,$>>:linux_specific>) + $<$:windows_specific> + $<$:macos_specific> + $<$,$>>:linux_specific>) -if(BUILD_WERROR) - if(MSVC) +if (BUILD_WERROR) + if (MSVC) target_compile_options(platform_specific INTERFACE /WX) - else() + else () target_compile_options(platform_specific INTERFACE -Werror) - endif() -endif() + endif () +endif () add_library(vulkan_registry INTERFACE) target_include_directories(vulkan_registry SYSTEM INTERFACE ${CMAKE_SOURCE_DIR}/external/Vulkan-Headers/include) @@ -359,7 +359,7 @@ target_include_directories(spirv_registry SYSTEM INTERFACE ${CMAKE_SOURCE_DIR}/e add_library(vulkan_memory_allocator INTERFACE) target_compile_options(vulkan_memory_allocator INTERFACE - $<$,$>: + $<$,$>: -Wno-nullability-completeness> ) target_include_directories(vulkan_memory_allocator SYSTEM INTERFACE ${CMAKE_SOURCE_DIR}/external/VulkanMemoryAllocator/include) @@ -374,23 +374,24 @@ add_subdirectory(external/SPIRV-Reflect EXCLUDE_FROM_ALL) if (${RUN_TESTS}) add_library(catch2 INTERFACE) target_include_directories(catch2 SYSTEM INTERFACE external) -endif() +endif () add_subdirectory(external/nlohmann) add_subdirectory(framework) -if(NOT BUILD_STATIC) +if (NOT BUILD_STATIC) add_subdirectory(layer) -endif() +endif () add_subdirectory(tools) -if(GFXRECON_INCLUDE_TEST_APPS) -add_subdirectory(test) -endif() +if (GFXRECON_INCLUDE_TEST_APPS) + add_subdirectory(external/Vulkan-Headers) + add_subdirectory(test) +endif () if (${RUN_TESTS}) add_test_package_file(${CMAKE_CURRENT_LIST_DIR}/scripts/build.py) add_test_package_file(${CMAKE_CURRENT_LIST_DIR}/scripts/test.py) generate_test_package(gfx_reconstruct_test) -endif() +endif () add_subdirectory(scripts) diff --git a/cmake/FindGoogleTest.cmake b/cmake/FindGoogleTest.cmake new file mode 100644 index 0000000000..80c6e549bd --- /dev/null +++ b/cmake/FindGoogleTest.cmake @@ -0,0 +1,8 @@ +include(FetchContent) + +FetchContent_Declare( + googletest + GIT_REPOSITORY https://github.com/google/googletest.git + GIT_TAG v1.15.2 +) +FetchContent_MakeAvailable(googletest) diff --git a/cmake/FindSDL3.cmake b/cmake/FindSDL3.cmake index bdbace5623..7df4223d40 100644 --- a/cmake/FindSDL3.cmake +++ b/cmake/FindSDL3.cmake @@ -3,6 +3,9 @@ include(FetchContent) set(SDL_GIT "https://github.com/libsdl-org/SDL.git") set(SDL_GIT_TAG "preview-3.1.3") message(STATUS "Fetching SDL3 files from ${SDL_GIT} ${SDL_GIT_TAG}") + +set(SDL_STATIC ON) + FetchContent_Declare( sdl GIT_REPOSITORY ${SDL_GIT} diff --git a/layer/json/VkLayer_gfxreconstruct.json.in b/layer/json/VkLayer_gfxreconstruct.json.in index 3665089339..59987a8f7a 100644 --- a/layer/json/VkLayer_gfxreconstruct.json.in +++ b/layer/json/VkLayer_gfxreconstruct.json.in @@ -18,6 +18,9 @@ "entrypoints": [ "vkGetPhysicalDeviceToolPropertiesEXT" ] } ], + "disable_environment": { + "GFXRECON_DISABLE": "" + }, "features": { "presets": [ { diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 9c5f1c5535..2100c8bffe 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -28,4 +28,45 @@ cmake_minimum_required(VERSION 3.24.0) add_subdirectory(test_apps) -# TODO: runner goes here +if (NOT DEFINED ENV{GFXRECON_NO_TEST_APPS}) + set(GFXRECON_INSTALL_TESTDIR ${CMAKE_INSTALL_PREFIX}/test) + + add_subdirectory(icd) + add_subdirectory(test_apps) + + enable_testing() + set(INSTALL_GTEST OFF) + find_package(GoogleTest REQUIRED) + include(GoogleTest) + add_executable(gfxrecon-testapp-runner + test_cases/triangle.cpp + test_cases/multisample-depth.cpp + test_cases/shader-objects.cpp + test_cases/pipeline-binaries.cpp + verify-gfxr.cpp + ) + add_dependencies(gfxrecon-testapp-runner gfxrecon-testapps VkICD_mock_icd gfxrecon-convert VkLayer_gfxreconstruct) + target_include_directories(gfxrecon-testapp-runner PRIVATE ${CMAKE_CURRENT_LIST_DIR}) + target_link_libraries(gfxrecon-testapp-runner + nlohmann_json::nlohmann_json + GTest::gtest GTest::gtest_main) + gtest_discover_tests(gfxrecon-testapp-runner) + + install(TARGETS gfxrecon-testapp-runner RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTDIR}) + install(DIRECTORY known_good DESTINATION ${GFXRECON_INSTALL_TESTDIR}) + install(TARGETS gfxrecon-convert RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTDIR}) + if (APPLE) + install(PROGRAMS run-tests_macos.sh DESTINATION ${GFXRECON_INSTALL_TESTDIR}) + install(FILES $/staging-json/VkLayer_gfxreconstruct.json DESTINATION ${GFXRECON_INSTALL_TESTDIR}/vulkan/explicit_layer.d) + install(TARGETS VkLayer_gfxreconstruct RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTDIR}/vulkan/explicit_layer.d LIBRARY DESTINATION ${GFXRECON_INSTALL_TESTDIR}/vulkan/explicit_layer.d) + elseif (UNIX) + install(PROGRAMS run-tests.sh DESTINATION ${GFXRECON_INSTALL_TESTDIR}) + install(FILES $/staging-json/VkLayer_gfxreconstruct.json DESTINATION ${GFXRECON_INSTALL_TESTDIR}/vulkan/explicit_layer.d) + install(TARGETS VkLayer_gfxreconstruct RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTDIR}/vulkan/explicit_layer.d LIBRARY DESTINATION ${GFXRECON_INSTALL_TESTDIR}/vulkan/explicit_layer.d) + else () + install(PROGRAMS run-tests.ps1 DESTINATION ${GFXRECON_INSTALL_TESTDIR}) + install(FILES $/VkLayer_gfxreconstruct.json DESTINATION ${GFXRECON_INSTALL_TESTDIR}) + install(TARGETS VkLayer_gfxreconstruct RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTDIR} LIBRARY DESTINATION ${GFXRECON_INSTALL_TESTDIR}) + endif () + +endif () diff --git a/test/icd/CMakeLists.txt b/test/icd/CMakeLists.txt new file mode 100644 index 0000000000..676e0e9e7e --- /dev/null +++ b/test/icd/CMakeLists.txt @@ -0,0 +1,132 @@ +# ~~~ +# Copyright (c) 2014-2018 Valve Corporation +# Copyright (c) 2014-2018 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. +# ~~~ + +if (ANDROID OR MINGW) + return() +endif() + +# These variables enable downstream users to customize the CMake targets +# based on the target API variant (e.g. Vulkan SC) +set(MOCK_ICD_NAME VkICD_mock_icd) +set(GENERATED generated) + +option(BUILD_MOCK_ANDROID_SUPPORT "Build with Android Platform headers" OFF) + +if(WIN32) + add_definitions(-DVK_USE_PLATFORM_WIN32_KHR -DVK_USE_PLATFORM_WIN32_KHX -DWIN32_LEAN_AND_MEAN) +elseif(APPLE) + add_definitions(-DVK_USE_PLATFORM_MACOS_MVK) +elseif(BUILD_MOCK_ANDROID_SUPPORT) + add_definitions(-DVK_USE_PLATFORM_ANDROID_KHR) +elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|BSD|GNU") + if(BUILD_WSI_XCB_SUPPORT) + add_definitions(-DVK_USE_PLATFORM_XCB_KHR -DVK_USE_PLATFORM_XCB_KHX) + endif() + + if(BUILD_WSI_XLIB_SUPPORT) + add_definitions(-DVK_USE_PLATFORM_XLIB_KHR -DVK_USE_PLATFORM_XLIB_KHX -DVK_USE_PLATFORM_XLIB_XRANDR_EXT) + endif() + + if(BUILD_WSI_WAYLAND_SUPPORT) + add_definitions(-DVK_USE_PLATFORM_WAYLAND_KHR -DVK_USE_PLATFORM_WAYLAND_KHX) + endif() +else() + message(FATAL_ERROR "Unsupported Platform!") +endif() + +add_library(VkICD_mock_icd MODULE) +target_sources(VkICD_mock_icd PRIVATE mock_icd.cpp) +target_link_libraries(VkICD_mock_icd PRIVATE Vulkan::Headers) + +target_include_directories(VkICD_mock_icd PUBLIC + ${GENERATED} + . +) + +if(${CMAKE_CXX_COMPILER_ID} MATCHES "GNU|Clang") + target_compile_options(VkICD_mock_icd PRIVATE + -Wpointer-arith + -Wno-unused-function + -Wno-sign-compare + ) +endif() + +if(MSVC) + target_compile_options(VkICD_mock_icd PRIVATE /bigobj) + target_compile_definitions(VkICD_mock_icd PRIVATE _CRT_SECURE_NO_WARNINGS) + target_link_options(VkICD_mock_icd PRIVATE /DEF:${CMAKE_CURRENT_SOURCE_DIR}/${MOCK_ICD_NAME}.def) +else() + if(APPLE) + set_target_properties(VkICD_mock_icd PROPERTIES SUFFIX ".dylib") + endif() + message(DEBUG "Mock ICD Functions are exported via EXPORT") +endif() + +set_target_properties(VkICD_mock_icd PROPERTIES OUTPUT_NAME ${MOCK_ICD_NAME}) + +if (DEFINED GIT_BRANCH_NAME AND DEFINED GIT_TAG_INFO) + target_compile_definitions(VkICD_mock_icd PRIVATE GIT_BRANCH_NAME="${GIT_BRANCH_NAME}" GIT_TAG_INFO="${GIT_TAG_INFO}") +endif() + +# There are 2 primary deliverables for the mock driver. +# - The actual library (lib)VkICD_mock_icd.(dll|so|dylib) +# - The respective json file, VkICD_mock_icd.json +# This code generates the appropriate json for both local testing and the installation. +# NOTE: For WIN32 the JSON and dll MUST be placed in the same location, due to Win32 using a relative path for installation. +set(INPUT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/${MOCK_ICD_NAME}.json.in") +set(INTERMEDIATE_FILE "${CMAKE_CURRENT_BINARY_DIR}/json/mock_icd.json") +set(OUTPUT_FILE_FINAL_NAME "${MOCK_ICD_NAME}.json") +set(LAYER_INSTALL_DIR ${GFXRECON_INSTALL_TESTDIR}/test_apps) +if (WIN32) + set(LAYER_INSTALL_DIR ${GFXRECON_INSTALL_TESTDIR}/test_apps) # WIN32 expect the dll in the `bin` dir, this matches our WIN32 SDK process +endif() + +if (WIN32) + set(JSON_LIBRARY_PATH ".\\\\${MOCK_ICD_NAME}.dll") +elseif(APPLE) + set(JSON_LIBRARY_PATH "./lib${MOCK_ICD_NAME}.dylib") +else() + set(JSON_LIBRARY_PATH "./lib${MOCK_ICD_NAME}.so") +endif() + +configure_file(${INPUT_FILE} ${INTERMEDIATE_FILE} @ONLY) + +# To support both multi/single configuration generators just copy the json to the correct directory +add_custom_command(TARGET VkICD_mock_icd POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${INTERMEDIATE_FILE} $/${OUTPUT_FILE_FINAL_NAME} +) + +# For UNIX-based systems, `library_path` should not contain a relative path (indicated by "./") before installing to system directories +# This json isn't used for regular local development, it's used for installation +if (UNIX) + set(UNIX_INTERMEDIATE_FILE "${CMAKE_CURRENT_BINARY_DIR}/json/unix_install_mock_icd.json") + + if(APPLE) + set(JSON_LIBRARY_PATH "lib${MOCK_ICD_NAME}.dylib") + else() + set(JSON_LIBRARY_PATH "lib${MOCK_ICD_NAME}.so") + endif() + + configure_file(${INPUT_FILE} ${UNIX_INTERMEDIATE_FILE} @ONLY) + + install(FILES ${UNIX_INTERMEDIATE_FILE} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/vulkan/icd.d RENAME ${OUTPUT_FILE_FINAL_NAME}) +endif() + +install(FILES ${INTERMEDIATE_FILE} DESTINATION ${LAYER_INSTALL_DIR} RENAME ${OUTPUT_FILE_FINAL_NAME}) + +install(TARGETS VkICD_mock_icd DESTINATION ${LAYER_INSTALL_DIR}) diff --git a/test/icd/README.md b/test/icd/README.md new file mode 100644 index 0000000000..1c6e6eae19 --- /dev/null +++ b/test/icd/README.md @@ -0,0 +1,80 @@ +# Vulkan Mock ICD + +This directory contains a mock ICD driver designed for validation layer testing. + +## Introduction + +The mock ICD is focused on enabling validation testing apart from an actual device. Because the validation layers +sit on top of the ICD and don't depend upon the results of Vulkan rendering, they can be tested without having actual +GPU hardware backing the ICD. The final mock driver will be composed of three main features: a null driver, flexible +device configuration, and entrypoint tracking & verification. + +### Null Driver +The intial mock driver features just the null driver capability. This allows all of the validation tests to be run +on a fixed device configuration that is hard-coded into the ICD. + +### Entrypoint Tracking & Verification +Entrypoint tracking and verification will be added to the mock layer as a later feature. The idea is that all expected +Vulkan function calls and their parameters can be stored in the ICD and then a separate call can be made to verify that +the exepected calls and parameters actually entered the ICD. This allows verification that the validation layers are +correctly passing calls and their parameters through to the ICD unchanged. + +## Using the Mock ICD + +To enable the mock ICD, set VK\_ICD\_FILENAMES environment variable to point to your {BUILD_DIR}/icd/VkICD\_mock\_icd.json. + +## Plans + +The initial mock ICD is just the null driver which can be used to test validation layers on +simulated devices. Here's a rough sequence of tasks planned for the mock driver going forward: +- [X] Get all LVL tests passing on the bare null driver +- [X] Get failing tests passing +- [X] Get skipped tests passing as able +- [ ] Get all LVL tests to run without unexpected errors +- [X] Develop automated test flow using mock ICD (alternative to or replacement for run\_all\_tests.sh) +- [ ] Update LVL tests with device dependencies to target specific device profiles +- [ ] Add entrypoint tracking & verification +- [ ] Initially track expected calls +- [ ] Update some tests to verify expected capability +- [ ] Expand tracking to include parameters + +## Beyond Validation Layer Testing + +The focus of the mock icd is for validation testing, but the code is available to use and enhance for anyone wishing to apply it for alternative +purposes. +With the following enhancements, the mock driver state available to the app should very closely mimic an actual ICD: +- Update various function return codes +- Simulated synchronization objects +- Simulated query with mock data +- Basic command buffer state tracking to note synch object transitions and query state updates + +Beyond that it's certainly possible that the mock icd could be hooked up to a SW renderer and serve as a virtual GPU with complete rendering/compute +capabilities. + +## Status + +This is a temporary section used for tracking as the mock icd is being developed. Once all tests are passing with the mock, this section can be removed. +Currently 333/333 tests are passing with the mock icd, but many passing tests have unexpected validation errors that need to be cleaned up. + +### Failing Tests + +NONE + +### Passing Tests With Unexpected Errors + +- VkLayerTest.RenderPassInUseDestroyedSignaled +- VkLayerTest.RenderPassIncompatible + +### Skipped Tests + +- VkLayerTest.BindImageInvalidMemoryType +- VkLayerTest.CreatePipelineBadVertexAttributeFormat +- VkLayerTest.MiscBlitImageTests +- VkLayerTest.TemporaryExternalSemaphore +- VkLayerTest.TemporaryExternalFence +- VkLayerTest.InvalidBarriers +- VkLayerTest.CommandQueueFlags +- VkPositiveLayerTest.TwoQueuesEnsureCorrectRetirementWithWorkStolen +- VkPositiveLayerTest.ExternalSemaphore +- VkPositiveLayerTest.ExternalFence +- VkPositiveLayerTest.ExternalMemory diff --git a/test/icd/VkICD_mock_icd.def b/test/icd/VkICD_mock_icd.def new file mode 100644 index 0000000000..73a4bedf57 --- /dev/null +++ b/test/icd/VkICD_mock_icd.def @@ -0,0 +1,37 @@ + +;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; +; 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: Tobin Ehlis +; +;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +LIBRARY VkICD_mock_icd +EXPORTS +vk_icdGetInstanceProcAddr +vk_icdGetPhysicalDeviceProcAddr +vk_icdNegotiateLoaderICDInterfaceVersion +vkDestroySurfaceKHR +vkGetPhysicalDeviceSurfaceSupportKHR +vkGetPhysicalDeviceSurfaceCapabilitiesKHR +vkGetPhysicalDeviceSurfaceFormatsKHR +vkGetPhysicalDeviceSurfacePresentModesKHR +vkCreateDisplayPlaneSurfaceKHR +vkCreateWin32SurfaceKHR +mockICD_getTestConfig diff --git a/test/icd/VkICD_mock_icd.json.in b/test/icd/VkICD_mock_icd.json.in new file mode 100644 index 0000000000..f10d3d29d0 --- /dev/null +++ b/test/icd/VkICD_mock_icd.json.in @@ -0,0 +1,7 @@ +{ + "file_format_version": "1.0.1", + "ICD": { + "library_path": "@JSON_LIBRARY_PATH@", + "api_version": "1.3.296" + } +} \ No newline at end of file diff --git a/test/icd/generated/.clang-format b/test/icd/generated/.clang-format new file mode 100644 index 0000000000..3bb983a45f --- /dev/null +++ b/test/icd/generated/.clang-format @@ -0,0 +1,5 @@ +--- +# Disable clang-format for generated code +DisableFormat: true +SortIncludes: false +... diff --git a/test/icd/generated/function_declarations.h b/test/icd/generated/function_declarations.h new file mode 100644 index 0000000000..45e6606ae8 --- /dev/null +++ b/test/icd/generated/function_declarations.h @@ -0,0 +1,5436 @@ +/* +** Copyright (c) 2015-2024 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 + +#include +#include +#include +#include +#include + +namespace vkmock { + +// Map of instance extension name to version +static const std::unordered_map instance_extension_map = { + {"VK_KHR_surface", 25}, + {"VK_KHR_display", 23}, + {"VK_KHR_xlib_surface", 6}, + {"VK_KHR_xcb_surface", 6}, + {"VK_KHR_wayland_surface", 6}, + {"VK_KHR_android_surface", 6}, + {"VK_KHR_win32_surface", 6}, + {"VK_EXT_debug_report", 10}, + {"VK_GGP_stream_descriptor_surface", 1}, + {"VK_NV_external_memory_capabilities", 1}, + {"VK_KHR_get_physical_device_properties2", 2}, + {"VK_EXT_validation_flags", 3}, + {"VK_NN_vi_surface", 1}, + {"VK_KHR_device_group_creation", 1}, + {"VK_KHR_external_memory_capabilities", 1}, + {"VK_KHR_external_semaphore_capabilities", 1}, + {"VK_EXT_direct_mode_display", 1}, + {"VK_EXT_acquire_xlib_display", 1}, + {"VK_EXT_display_surface_counter", 1}, + {"VK_EXT_swapchain_colorspace", 5}, + {"VK_KHR_external_fence_capabilities", 1}, + {"VK_KHR_get_surface_capabilities2", 1}, + {"VK_KHR_get_display_properties2", 1}, + {"VK_MVK_ios_surface", 3}, + {"VK_MVK_macos_surface", 3}, + {"VK_EXT_debug_utils", 2}, + {"VK_FUCHSIA_imagepipe_surface", 1}, + {"VK_EXT_metal_surface", 1}, + {"VK_KHR_surface_protected_capabilities", 1}, + {"VK_EXT_validation_features", 6}, + {"VK_EXT_headless_surface", 1}, + {"VK_EXT_surface_maintenance1", 1}, + {"VK_EXT_acquire_drm_display", 1}, + {"VK_EXT_directfb_surface", 1}, + {"VK_QNX_screen_surface", 1}, + {"VK_KHR_portability_enumeration", 1}, + {"VK_GOOGLE_surfaceless_query", 2}, + {"VK_LUNARG_direct_driver_loading", 1}, + {"VK_EXT_layer_settings", 2}, +}; +// Map of device extension name to version +static const std::unordered_map device_extension_map = { + {"VK_KHR_swapchain", 70}, + {"VK_KHR_display_swapchain", 10}, + {"VK_NV_glsl_shader", 1}, + {"VK_EXT_depth_range_unrestricted", 1}, + {"VK_KHR_sampler_mirror_clamp_to_edge", 3}, + {"VK_IMG_filter_cubic", 1}, + {"VK_AMD_rasterization_order", 1}, + {"VK_AMD_shader_trinary_minmax", 1}, + {"VK_AMD_shader_explicit_vertex_parameter", 1}, + {"VK_EXT_debug_marker", 4}, + {"VK_KHR_video_queue", 8}, + {"VK_KHR_video_decode_queue", 8}, + {"VK_AMD_gcn_shader", 1}, + {"VK_NV_dedicated_allocation", 1}, + {"VK_EXT_transform_feedback", 1}, + {"VK_NVX_binary_import", 1}, + {"VK_NVX_image_view_handle", 2}, + {"VK_AMD_draw_indirect_count", 2}, + {"VK_AMD_negative_viewport_height", 1}, + {"VK_AMD_gpu_shader_half_float", 2}, + {"VK_AMD_shader_ballot", 1}, + {"VK_KHR_video_encode_h264", 14}, + {"VK_KHR_video_encode_h265", 14}, + {"VK_KHR_video_decode_h264", 9}, + {"VK_AMD_texture_gather_bias_lod", 1}, + {"VK_AMD_shader_info", 1}, + {"VK_KHR_dynamic_rendering", 1}, + {"VK_AMD_shader_image_load_store_lod", 1}, + {"VK_NV_corner_sampled_image", 2}, + {"VK_KHR_multiview", 1}, + {"VK_IMG_format_pvrtc", 1}, + {"VK_NV_external_memory", 1}, + {"VK_NV_external_memory_win32", 1}, + {"VK_NV_win32_keyed_mutex", 2}, + {"VK_KHR_device_group", 4}, + {"VK_KHR_shader_draw_parameters", 1}, + {"VK_EXT_shader_subgroup_ballot", 1}, + {"VK_EXT_shader_subgroup_vote", 1}, + {"VK_EXT_texture_compression_astc_hdr", 1}, + {"VK_EXT_astc_decode_mode", 1}, + {"VK_EXT_pipeline_robustness", 1}, + {"VK_KHR_maintenance1", 2}, + {"VK_KHR_external_memory", 1}, + {"VK_KHR_external_memory_win32", 1}, + {"VK_KHR_external_memory_fd", 1}, + {"VK_KHR_win32_keyed_mutex", 1}, + {"VK_KHR_external_semaphore", 1}, + {"VK_KHR_external_semaphore_win32", 1}, + {"VK_KHR_external_semaphore_fd", 1}, + {"VK_KHR_push_descriptor", 2}, + {"VK_EXT_conditional_rendering", 2}, + {"VK_KHR_shader_float16_int8", 1}, + {"VK_KHR_16bit_storage", 1}, + {"VK_KHR_incremental_present", 2}, + {"VK_KHR_descriptor_update_template", 1}, + {"VK_NV_clip_space_w_scaling", 1}, + {"VK_EXT_display_control", 1}, + {"VK_GOOGLE_display_timing", 1}, + {"VK_NV_sample_mask_override_coverage", 1}, + {"VK_NV_geometry_shader_passthrough", 1}, + {"VK_NV_viewport_array2", 1}, + {"VK_NVX_multiview_per_view_attributes", 1}, + {"VK_NV_viewport_swizzle", 1}, + {"VK_EXT_discard_rectangles", 2}, + {"VK_EXT_conservative_rasterization", 1}, + {"VK_EXT_depth_clip_enable", 1}, + {"VK_EXT_hdr_metadata", 3}, + {"VK_KHR_imageless_framebuffer", 1}, + {"VK_KHR_create_renderpass2", 1}, + {"VK_IMG_relaxed_line_rasterization", 1}, + {"VK_KHR_shared_presentable_image", 1}, + {"VK_KHR_external_fence", 1}, + {"VK_KHR_external_fence_win32", 1}, + {"VK_KHR_external_fence_fd", 1}, + {"VK_KHR_performance_query", 1}, + {"VK_KHR_maintenance2", 1}, + {"VK_KHR_variable_pointers", 1}, + {"VK_EXT_external_memory_dma_buf", 1}, + {"VK_EXT_queue_family_foreign", 1}, + {"VK_KHR_dedicated_allocation", 3}, + {"VK_ANDROID_external_memory_android_hardware_buffer", 5}, + {"VK_EXT_sampler_filter_minmax", 2}, + {"VK_KHR_storage_buffer_storage_class", 1}, + {"VK_AMD_gpu_shader_int16", 2}, + {"VK_AMDX_shader_enqueue", 1}, + {"VK_AMD_mixed_attachment_samples", 1}, + {"VK_AMD_shader_fragment_mask", 1}, + {"VK_EXT_inline_uniform_block", 1}, + {"VK_EXT_shader_stencil_export", 1}, + {"VK_EXT_sample_locations", 1}, + {"VK_KHR_relaxed_block_layout", 1}, + {"VK_KHR_get_memory_requirements2", 1}, + {"VK_KHR_image_format_list", 1}, + {"VK_EXT_blend_operation_advanced", 2}, + {"VK_NV_fragment_coverage_to_color", 1}, + {"VK_KHR_acceleration_structure", 13}, + {"VK_KHR_ray_tracing_pipeline", 1}, + {"VK_KHR_ray_query", 1}, + {"VK_NV_framebuffer_mixed_samples", 1}, + {"VK_NV_fill_rectangle", 1}, + {"VK_NV_shader_sm_builtins", 1}, + {"VK_EXT_post_depth_coverage", 1}, + {"VK_KHR_sampler_ycbcr_conversion", 14}, + {"VK_KHR_bind_memory2", 1}, + {"VK_EXT_image_drm_format_modifier", 2}, + {"VK_EXT_descriptor_indexing", 2}, + {"VK_EXT_shader_viewport_index_layer", 1}, + {"VK_NV_shading_rate_image", 3}, + {"VK_NV_ray_tracing", 3}, + {"VK_NV_representative_fragment_test", 2}, + {"VK_KHR_maintenance3", 1}, + {"VK_KHR_draw_indirect_count", 1}, + {"VK_EXT_filter_cubic", 3}, + {"VK_QCOM_render_pass_shader_resolve", 4}, + {"VK_EXT_global_priority", 2}, + {"VK_KHR_shader_subgroup_extended_types", 1}, + {"VK_KHR_8bit_storage", 1}, + {"VK_EXT_external_memory_host", 1}, + {"VK_AMD_buffer_marker", 1}, + {"VK_KHR_shader_atomic_int64", 1}, + {"VK_KHR_shader_clock", 1}, + {"VK_AMD_pipeline_compiler_control", 1}, + {"VK_EXT_calibrated_timestamps", 2}, + {"VK_AMD_shader_core_properties", 2}, + {"VK_KHR_video_decode_h265", 8}, + {"VK_KHR_global_priority", 1}, + {"VK_AMD_memory_overallocation_behavior", 1}, + {"VK_EXT_vertex_attribute_divisor", 3}, + {"VK_GGP_frame_token", 1}, + {"VK_EXT_pipeline_creation_feedback", 1}, + {"VK_KHR_driver_properties", 1}, + {"VK_KHR_shader_float_controls", 4}, + {"VK_NV_shader_subgroup_partitioned", 1}, + {"VK_KHR_depth_stencil_resolve", 1}, + {"VK_KHR_swapchain_mutable_format", 1}, + {"VK_NV_compute_shader_derivatives", 1}, + {"VK_NV_mesh_shader", 1}, + {"VK_NV_fragment_shader_barycentric", 1}, + {"VK_NV_shader_image_footprint", 2}, + {"VK_NV_scissor_exclusive", 2}, + {"VK_NV_device_diagnostic_checkpoints", 2}, + {"VK_KHR_timeline_semaphore", 2}, + {"VK_INTEL_shader_integer_functions2", 1}, + {"VK_INTEL_performance_query", 2}, + {"VK_KHR_vulkan_memory_model", 3}, + {"VK_EXT_pci_bus_info", 2}, + {"VK_AMD_display_native_hdr", 1}, + {"VK_KHR_shader_terminate_invocation", 1}, + {"VK_EXT_fragment_density_map", 2}, + {"VK_EXT_scalar_block_layout", 1}, + {"VK_GOOGLE_hlsl_functionality1", 1}, + {"VK_GOOGLE_decorate_string", 1}, + {"VK_EXT_subgroup_size_control", 2}, + {"VK_KHR_fragment_shading_rate", 2}, + {"VK_AMD_shader_core_properties2", 1}, + {"VK_AMD_device_coherent_memory", 1}, + {"VK_KHR_dynamic_rendering_local_read", 1}, + {"VK_EXT_shader_image_atomic_int64", 1}, + {"VK_KHR_shader_quad_control", 1}, + {"VK_KHR_spirv_1_4", 1}, + {"VK_EXT_memory_budget", 1}, + {"VK_EXT_memory_priority", 1}, + {"VK_NV_dedicated_allocation_image_aliasing", 1}, + {"VK_KHR_separate_depth_stencil_layouts", 1}, + {"VK_EXT_buffer_device_address", 2}, + {"VK_EXT_tooling_info", 1}, + {"VK_EXT_separate_stencil_usage", 1}, + {"VK_KHR_present_wait", 1}, + {"VK_NV_cooperative_matrix", 1}, + {"VK_NV_coverage_reduction_mode", 1}, + {"VK_EXT_fragment_shader_interlock", 1}, + {"VK_EXT_ycbcr_image_arrays", 1}, + {"VK_KHR_uniform_buffer_standard_layout", 1}, + {"VK_EXT_provoking_vertex", 1}, + {"VK_EXT_full_screen_exclusive", 4}, + {"VK_KHR_buffer_device_address", 1}, + {"VK_EXT_line_rasterization", 1}, + {"VK_EXT_shader_atomic_float", 1}, + {"VK_EXT_host_query_reset", 1}, + {"VK_EXT_index_type_uint8", 1}, + {"VK_EXT_extended_dynamic_state", 1}, + {"VK_KHR_deferred_host_operations", 4}, + {"VK_KHR_pipeline_executable_properties", 1}, + {"VK_EXT_host_image_copy", 1}, + {"VK_KHR_map_memory2", 1}, + {"VK_EXT_map_memory_placed", 1}, + {"VK_EXT_shader_atomic_float2", 1}, + {"VK_EXT_swapchain_maintenance1", 1}, + {"VK_EXT_shader_demote_to_helper_invocation", 1}, + {"VK_NV_device_generated_commands", 3}, + {"VK_NV_inherited_viewport_scissor", 1}, + {"VK_KHR_shader_integer_dot_product", 1}, + {"VK_EXT_texel_buffer_alignment", 1}, + {"VK_QCOM_render_pass_transform", 4}, + {"VK_EXT_depth_bias_control", 1}, + {"VK_EXT_device_memory_report", 2}, + {"VK_EXT_robustness2", 1}, + {"VK_EXT_custom_border_color", 12}, + {"VK_GOOGLE_user_type", 1}, + {"VK_KHR_pipeline_library", 1}, + {"VK_NV_present_barrier", 1}, + {"VK_KHR_shader_non_semantic_info", 1}, + {"VK_KHR_present_id", 1}, + {"VK_EXT_private_data", 1}, + {"VK_EXT_pipeline_creation_cache_control", 3}, + {"VK_KHR_video_encode_queue", 12}, + {"VK_NV_device_diagnostics_config", 2}, + {"VK_QCOM_render_pass_store_ops", 2}, + {"VK_NV_cuda_kernel_launch", 2}, + {"VK_NV_low_latency", 1}, + {"VK_EXT_metal_objects", 2}, + {"VK_KHR_synchronization2", 1}, + {"VK_EXT_descriptor_buffer", 1}, + {"VK_EXT_graphics_pipeline_library", 1}, + {"VK_AMD_shader_early_and_late_fragment_tests", 1}, + {"VK_KHR_fragment_shader_barycentric", 1}, + {"VK_KHR_shader_subgroup_uniform_control_flow", 1}, + {"VK_KHR_zero_initialize_workgroup_memory", 1}, + {"VK_NV_fragment_shading_rate_enums", 1}, + {"VK_NV_ray_tracing_motion_blur", 1}, + {"VK_EXT_mesh_shader", 1}, + {"VK_EXT_ycbcr_2plane_444_formats", 1}, + {"VK_EXT_fragment_density_map2", 1}, + {"VK_QCOM_rotated_copy_commands", 2}, + {"VK_EXT_image_robustness", 1}, + {"VK_KHR_workgroup_memory_explicit_layout", 1}, + {"VK_KHR_copy_commands2", 1}, + {"VK_EXT_image_compression_control", 1}, + {"VK_EXT_attachment_feedback_loop_layout", 2}, + {"VK_EXT_4444_formats", 1}, + {"VK_EXT_device_fault", 2}, + {"VK_ARM_rasterization_order_attachment_access", 1}, + {"VK_EXT_rgba10x6_formats", 1}, + {"VK_NV_acquire_winrt_display", 1}, + {"VK_VALVE_mutable_descriptor_type", 1}, + {"VK_EXT_vertex_input_dynamic_state", 2}, + {"VK_EXT_physical_device_drm", 1}, + {"VK_EXT_device_address_binding_report", 1}, + {"VK_EXT_depth_clip_control", 1}, + {"VK_EXT_primitive_topology_list_restart", 1}, + {"VK_KHR_format_feature_flags2", 2}, + {"VK_FUCHSIA_external_memory", 1}, + {"VK_FUCHSIA_external_semaphore", 1}, + {"VK_FUCHSIA_buffer_collection", 2}, + {"VK_HUAWEI_subpass_shading", 3}, + {"VK_HUAWEI_invocation_mask", 1}, + {"VK_NV_external_memory_rdma", 1}, + {"VK_EXT_pipeline_properties", 1}, + {"VK_EXT_frame_boundary", 1}, + {"VK_EXT_multisampled_render_to_single_sampled", 1}, + {"VK_EXT_extended_dynamic_state2", 1}, + {"VK_EXT_color_write_enable", 1}, + {"VK_EXT_primitives_generated_query", 1}, + {"VK_KHR_ray_tracing_maintenance1", 1}, + {"VK_EXT_global_priority_query", 1}, + {"VK_EXT_image_view_min_lod", 1}, + {"VK_EXT_multi_draw", 1}, + {"VK_EXT_image_2d_view_of_3d", 1}, + {"VK_EXT_shader_tile_image", 1}, + {"VK_EXT_opacity_micromap", 2}, + {"VK_NV_displacement_micromap", 2}, + {"VK_EXT_load_store_op_none", 1}, + {"VK_HUAWEI_cluster_culling_shader", 3}, + {"VK_EXT_border_color_swizzle", 1}, + {"VK_EXT_pageable_device_local_memory", 1}, + {"VK_KHR_maintenance4", 2}, + {"VK_ARM_shader_core_properties", 1}, + {"VK_KHR_shader_subgroup_rotate", 2}, + {"VK_ARM_scheduling_controls", 1}, + {"VK_EXT_image_sliced_view_of_3d", 1}, + {"VK_VALVE_descriptor_set_host_mapping", 1}, + {"VK_EXT_depth_clamp_zero_one", 1}, + {"VK_EXT_non_seamless_cube_map", 1}, + {"VK_ARM_render_pass_striped", 1}, + {"VK_QCOM_fragment_density_map_offset", 2}, + {"VK_NV_copy_memory_indirect", 1}, + {"VK_NV_memory_decompression", 1}, + {"VK_NV_device_generated_commands_compute", 2}, + {"VK_NV_linear_color_attachment", 1}, + {"VK_KHR_shader_maximal_reconvergence", 1}, + {"VK_EXT_image_compression_control_swapchain", 1}, + {"VK_QCOM_image_processing", 1}, + {"VK_EXT_nested_command_buffer", 1}, + {"VK_EXT_external_memory_acquire_unmodified", 1}, + {"VK_EXT_extended_dynamic_state3", 2}, + {"VK_EXT_subpass_merge_feedback", 2}, + {"VK_EXT_shader_module_identifier", 1}, + {"VK_EXT_rasterization_order_attachment_access", 1}, + {"VK_NV_optical_flow", 1}, + {"VK_EXT_legacy_dithering", 2}, + {"VK_EXT_pipeline_protected_access", 1}, + {"VK_ANDROID_external_format_resolve", 1}, + {"VK_KHR_maintenance5", 1}, + {"VK_AMD_anti_lag", 1}, + {"VK_KHR_ray_tracing_position_fetch", 1}, + {"VK_EXT_shader_object", 1}, + {"VK_KHR_pipeline_binary", 1}, + {"VK_QCOM_tile_properties", 1}, + {"VK_SEC_amigo_profiling", 1}, + {"VK_QCOM_multiview_per_view_viewports", 1}, + {"VK_NV_ray_tracing_invocation_reorder", 1}, + {"VK_NV_extended_sparse_address_space", 1}, + {"VK_EXT_mutable_descriptor_type", 1}, + {"VK_EXT_legacy_vertex_attributes", 1}, + {"VK_ARM_shader_core_builtins", 2}, + {"VK_EXT_pipeline_library_group_handles", 1}, + {"VK_EXT_dynamic_rendering_unused_attachments", 1}, + {"VK_NV_low_latency2", 2}, + {"VK_KHR_cooperative_matrix", 2}, + {"VK_QCOM_multiview_per_view_render_areas", 1}, + {"VK_KHR_compute_shader_derivatives", 1}, + {"VK_KHR_video_decode_av1", 1}, + {"VK_KHR_video_maintenance1", 1}, + {"VK_NV_per_stage_descriptor_set", 1}, + {"VK_QCOM_image_processing2", 1}, + {"VK_QCOM_filter_cubic_weights", 1}, + {"VK_QCOM_ycbcr_degamma", 1}, + {"VK_QCOM_filter_cubic_clamp", 1}, + {"VK_EXT_attachment_feedback_loop_dynamic_state", 1}, + {"VK_KHR_vertex_attribute_divisor", 1}, + {"VK_KHR_load_store_op_none", 1}, + {"VK_KHR_shader_float_controls2", 1}, + {"VK_QNX_external_memory_screen_buffer", 1}, + {"VK_MSFT_layered_driver", 1}, + {"VK_KHR_index_type_uint8", 1}, + {"VK_KHR_line_rasterization", 1}, + {"VK_KHR_calibrated_timestamps", 1}, + {"VK_KHR_shader_expect_assume", 1}, + {"VK_KHR_maintenance6", 1}, + {"VK_NV_descriptor_pool_overallocation", 1}, + {"VK_NV_raw_access_chains", 1}, + {"VK_KHR_shader_relaxed_extended_instruction", 1}, + {"VK_NV_command_buffer_inheritance", 1}, + {"VK_KHR_maintenance7", 1}, + {"VK_NV_shader_atomic_float16_vector", 1}, + {"VK_EXT_shader_replicated_composites", 1}, + {"VK_NV_ray_tracing_validation", 1}, + {"VK_EXT_device_generated_commands", 1}, + {"VK_MESA_image_alignment_control", 1}, + {"VK_EXT_depth_clamp_control", 1}, +}; + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); + +static VKAPI_ATTR void VKAPI_CALL DestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( + VkInstance instance, + const char* pName); + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( + VkDevice device, + const char* pName); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); + +static VKAPI_ATTR void VKAPI_CALL DestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( + VkQueue queue); + +static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( + VkDevice device); + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); + +static VKAPI_ATTR void VKAPI_CALL FreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +static VKAPI_ATTR void VKAPI_CALL UnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +static VKAPI_ATTR void VKAPI_CALL DestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( + VkDevice device, + VkFence fence); + +static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); + +static VKAPI_ATTR void VKAPI_CALL DestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +static VKAPI_ATTR void VKAPI_CALL DestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( + VkDevice device, + VkEvent event); + +static VKAPI_ATTR VkResult VKAPI_CALL SetEvent( + VkDevice device, + VkEvent event); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( + VkDevice device, + VkEvent event); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); + +static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); + +static VKAPI_ATTR void VKAPI_CALL DestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +static VKAPI_ATTR void VKAPI_CALL DestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); + +static VKAPI_ATTR void VKAPI_CALL DestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); + +static VKAPI_ATTR void VKAPI_CALL DestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule); + +static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +static VKAPI_ATTR void VKAPI_CALL DestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); + +static VKAPI_ATTR void VKAPI_CALL DestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + +static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports); + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +static VKAPI_ATTR void VKAPI_CALL CmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion( + uint32_t* pApiVersion); + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); + +static VKAPI_ATTR void VKAPI_CALL TrimCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( + VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo); + +static VKAPI_ATTR void VKAPI_CALL ResetQueryPool( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); + +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); + +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data); + +static VKAPI_ATTR void VKAPI_CALL GetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask); + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + + +static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); + +static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); + +static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( + VkDevice device, + const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); + +#ifdef VK_USE_PLATFORM_XLIB_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID); +#endif /* VK_USE_PLATFORM_XLIB_KHR */ + +#ifdef VK_USE_PLATFORM_XCB_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR( + VkInstance instance, + const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id); +#endif /* VK_USE_PLATFORM_XCB_KHR */ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR( + VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display); +#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR( + VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR( + VkInstance instance, + const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR* pVideoFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR( + VkDevice device, + const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession); + +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); + +static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR( + VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters); + +static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); + +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo); + + +static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoDecodeInfoKHR* pDecodeInfo); + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR( + VkCommandBuffer commandBuffer); + + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); + + +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + + + +static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); + + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData); + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR( + VkDevice device, + const VkAcquireProfilingLockInfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR( + VkDevice device); + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); + + + + + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); + + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + + + + + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); + +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); + +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR( + VkCommandBuffer commandBuffer, + const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); + + +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocationsKHR( + VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfoKHR* pLocationInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndicesKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInputAttachmentIndexInfoKHR* pInputAttachmentIndexInfo); + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t presentId, + uint64_t timeout); + + + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR( + VkDevice device, + const VkAllocationCallbacks* pAllocator, + VkDeferredOperationKHR* pDeferredOperation); + +static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR( + VkDevice device, + VkDeferredOperationKHR operation, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR( + VkDevice device, + VkDeferredOperationKHR operation); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR( + VkDevice device, + VkDeferredOperationKHR operation); + +static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR( + VkDevice device, + VkDeferredOperationKHR operation); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( + VkDevice device, + const VkPipelineInfoKHR* pPipelineInfo, + uint32_t* pExecutableCount, + VkPipelineExecutablePropertiesKHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pStatisticCount, + VkPipelineExecutableStatisticKHR* pStatistics); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pInternalRepresentationCount, + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); + + +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR( + VkDevice device, + const VkMemoryMapInfoKHR* pMemoryMapInfo, + void** ppData); + +static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR( + VkDevice device, + const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetEncodedVideoSessionParametersKHR( + VkDevice device, + const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, + size_t* pDataSize, + void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoEncodeInfoKHR* pEncodeInfo); + + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask); + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); + +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData); + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo); + + + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectDeviceAddress); + + + +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType); + +static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR( + VkDevice device, + const VkRenderingAreaInfoKHR* pRenderingAreaInfo, + VkExtent2D* pGranularity); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR( + VkDevice device, + const VkDeviceImageSubresourceInfoKHR* pInfo, + VkSubresourceLayout2KHR* pLayout); + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR( + VkDevice device, + VkImage image, + const VkImageSubresource2KHR* pSubresource, + VkSubresourceLayout2KHR* pLayout); + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineBinariesKHR( + VkDevice device, + const VkPipelineBinaryCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineBinaryHandlesInfoKHR* pBinaries); + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineBinaryKHR( + VkDevice device, + VkPipelineBinaryKHR pipelineBinary, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineKeyKHR( + VkDevice device, + const VkPipelineCreateInfoKHR* pPipelineCreateInfo, + VkPipelineBinaryKeyKHR* pPipelineKey); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineBinaryDataKHR( + VkDevice device, + const VkPipelineBinaryDataInfoKHR* pInfo, + VkPipelineBinaryKeyKHR* pPipelineBinaryKey, + size_t* pPipelineBinaryDataSize, + void* pPipelineBinaryData); + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseCapturedPipelineDataKHR( + VkDevice device, + const VkReleaseCapturedPipelineDataInfoKHR* pInfo, + const VkAllocationCallbacks* pAllocator); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesKHR* pProperties); + + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleKHR( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains); + +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR( + VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR( + VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback); + +static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage); + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( + VkDevice device, + const VkDebugMarkerObjectTagInfoEXT* pTagInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( + VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags, + uint32_t index); + +static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + uint32_t index); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT( + VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX( + VkDevice device, + const VkCuModuleCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuModuleNVX* pModule); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX( + VkDevice device, + const VkCuFunctionCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuFunctionNVX* pFunction); + +static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX( + VkDevice device, + VkCuModuleNVX module, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX( + VkDevice device, + VkCuFunctionNVX function, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX( + VkCommandBuffer commandBuffer, + const VkCuLaunchInfoNVX* pLaunchInfo); + + +static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX( + VkDevice device, + const VkImageViewHandleInfoNVX* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX( + VkDevice device, + VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties); + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD( + VkDevice device, + VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t* pInfoSize, + void* pInfo); + + +#ifdef VK_USE_PLATFORM_GGP + +static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP( + VkInstance instance, + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_GGP */ + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +#ifdef VK_USE_PLATFORM_VI_NN + +static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN( + VkInstance instance, + const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_VI_NN */ + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); + +static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT( + VkCommandBuffer commandBuffer); + + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings); + + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + VkDisplayKHR display); + +static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay); +#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + + +static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings); + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 discardRectangleEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT( + VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode); + + + + + +static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata); + + +#ifdef VK_USE_PLATFORM_IOS_MVK + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_IOS_MVK */ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK( + VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_MACOS_MVK */ + + + + +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( + VkDevice device, + const VkDebugUtilsObjectNameInfoEXT* pNameInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( + VkDevice device, + const VkDebugUtilsObjectTagInfoEXT* pTagInfo); + +static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( + VkQueue queue); + +static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger); + +static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( + VkDevice device, + const struct AHardwareBuffer* buffer, + VkAndroidHardwareBufferPropertiesANDROID* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( + VkDevice device, + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, + struct AHardwareBuffer** pBuffer); +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + + + +#ifdef VK_ENABLE_BETA_EXTENSIONS + +static VKAPI_ATTR VkResult VKAPI_CALL CreateExecutionGraphPipelinesAMDX( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineScratchSizeAMDX( + VkDevice device, + VkPipeline executionGraph, + VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineNodeIndexAMDX( + VkDevice device, + VkPipeline executionGraph, + const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, + uint32_t* pNodeIndex); + +static VKAPI_ATTR void VKAPI_CALL CmdInitializeGraphScratchMemoryAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + const VkDispatchGraphCountInfoAMDX* pCountInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + const VkDispatchGraphCountInfoAMDX* pCountInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectCountAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + VkDeviceAddress countInfo); +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT( + VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( + VkDevice device, + const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache); + +static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( + VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches); + +static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + size_t* pDataSize, + void* pData); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV( + VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV( + VkDevice device, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure); + +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV( + VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV( + VkDevice device, + uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV( + VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV* pInfo, + VkBuffer instanceData, + VkDeviceSize instanceOffset, + VkBool32 update, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkBuffer scratch, + VkDeviceSize scratchOffset); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV( + VkCommandBuffer commandBuffer, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeKHR mode); + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV( + VkCommandBuffer commandBuffer, + VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, + VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, + VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, + VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, + VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, + VkDeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, + void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV( + VkDevice device, + VkPipeline pipeline, + uint32_t shader); + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); + + +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains); + +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); + + + + +#ifdef VK_USE_PLATFORM_GGP +#endif /* VK_USE_PLATFORM_GGP */ + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV( + VkCommandBuffer commandBuffer, + uint32_t taskCount, + uint32_t firstTask); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables); + +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D* pExclusiveScissors); + + +static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV( + VkCommandBuffer commandBuffer, + const void* pCheckpointMarker); + +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData); + + + +static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL( + VkDevice device, + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); + +static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL( + VkDevice device); + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceMarkerInfoINTEL* pMarkerInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceOverrideInfoINTEL* pOverrideInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL( + VkDevice device, + const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, + VkPerformanceConfigurationINTEL* pConfiguration); + +static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL( + VkDevice device, + VkPerformanceConfigurationINTEL configuration); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL( + VkQueue queue, + VkPerformanceConfigurationINTEL configuration); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL( + VkDevice device, + VkPerformanceParameterTypeINTEL parameter, + VkPerformanceValueINTEL* pValue); + + + +static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD( + VkDevice device, + VkSwapchainKHR swapChain, + VkBool32 localDimmingEnable); + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( + VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_METAL_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT( + VkInstance instance, + const VkMetalSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_METAL_EXT */ + + + + + + + + + + + + + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + VkPhysicalDevice physicalDevice, + uint32_t* pCombinationCount, + VkFramebufferMixedSamplesCombinationNV* pCombinations); + + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain); + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT( + VkDevice device, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR* pModes); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT( + VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); + + + +static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); + + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImageEXT( + VkDevice device, + const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemoryEXT( + VkDevice device, + const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImageEXT( + VkDevice device, + const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT( + VkDevice device, + uint32_t transitionCount, + const VkHostImageLayoutTransitionInfoEXT* pTransitions); + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( + VkDevice device, + VkImage image, + const VkImageSubresource2KHR* pSubresource, + VkSubresourceLayout2KHR* pLayout); + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT( + VkDevice device, + const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); + + + +static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, + uint32_t groupIndex); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); + +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV( + VkDevice device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT( + VkCommandBuffer commandBuffer, + const VkDepthBiasInfoEXT* pDepthBiasInfo); + + + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + VkDisplayKHR display); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + uint32_t connectorId, + VkDisplayKHR* display); + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); + +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data); + +static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData); + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaModuleNV( + VkDevice device, + const VkCudaModuleCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCudaModuleNV* pModule); + +static VKAPI_ATTR VkResult VKAPI_CALL GetCudaModuleCacheNV( + VkDevice device, + VkCudaModuleNV module, + size_t* pCacheSize, + void* pCacheData); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaFunctionNV( + VkDevice device, + const VkCudaFunctionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCudaFunctionNV* pFunction); + +static VKAPI_ATTR void VKAPI_CALL DestroyCudaModuleNV( + VkDevice device, + VkCudaModuleNV module, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL DestroyCudaFunctionNV( + VkDevice device, + VkCudaFunctionNV function, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdCudaLaunchKernelNV( + VkCommandBuffer commandBuffer, + const VkCudaLaunchInfoNV* pLaunchInfo); + + +#ifdef VK_USE_PLATFORM_METAL_EXT + +static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT( + VkDevice device, + VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); +#endif /* VK_USE_PLATFORM_METAL_EXT */ + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT( + VkDevice device, + VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes); + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT( + VkDevice device, + VkDescriptorSetLayout layout, + uint32_t binding, + VkDeviceSize* pOffset); + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT( + VkDevice device, + const VkDescriptorGetInfoEXT* pDescriptorInfo, + size_t dataSize, + void* pDescriptor); + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsetsEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t* pBufferIndices, + const VkDeviceSize* pOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set); + +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV( + VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); + + + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo); + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); + +static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT( + VkInstance instance, + const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + IDirectFB* dfb); +#endif /* VK_USE_PLATFORM_DIRECTFB_EXT */ + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT( + VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); + + + + + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( + VkDevice device, + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle); + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle); +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA( + VkDevice device, + const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferCollectionFUCHSIA* pCollection); + +static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); + +static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA* pProperties); +#endif /* VK_USE_PLATFORM_FUCHSIA */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + VkDevice device, + VkRenderPass renderpass, + VkExtent2D* pMaxWorkgroupSize); + +static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI( + VkCommandBuffer commandBuffer); + + +static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV( + VkDevice device, + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV* pAddress); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT( + VkDevice device, + const VkPipelineInfoEXT* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT( + VkCommandBuffer commandBuffer, + uint32_t patchControlPoints); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT( + VkCommandBuffer commandBuffer, + VkLogicOp logicOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); + +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX( + VkInstance instance, + const VkScreenSurfaceCreateInfoQNX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window* window); +#endif /* VK_USE_PLATFORM_SCREEN_QNX */ + + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkBool32* pColorWriteEnables); + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawInfoEXT* pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT* pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t* pVertexOffset); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( + VkDevice device, + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap); + +static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( + VkDevice device, + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT( + VkDevice device, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( + VkDevice device, + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); + +static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo); + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterHUAWEI( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + + + +static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( + VkDevice device, + VkDeviceMemory memory, + float priority); + + + + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE( + VkDevice device, + const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( + VkDevice device, + VkDescriptorSet descriptorSet, + void** ppData); + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources); + + +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV( + VkCommandBuffer commandBuffer, + uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride); + + +static VKAPI_ATTR void VKAPI_CALL GetPipelineIndirectMemoryRequirementsNV( + VkDevice device, + const VkComputePipelineCreateInfo* pCreateInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL CmdUpdatePipelineIndirectBufferNV( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetPipelineIndirectDeviceAddressNV( + VkDevice device, + const VkPipelineIndirectDeviceAddressInfoNV* pInfo); + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClampEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( + VkCommandBuffer commandBuffer, + VkPolygonMode polygonMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples); + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask); + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks); + +static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream); + +static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced); + +static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode); + + + + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( + VkDevice device, + VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier); + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier); + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession); + +static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout); + +static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo); + + + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + + +static VKAPI_ATTR void VKAPI_CALL AntiLagUpdateAMD( + VkDevice device, + const VkAntiLagDataAMD* pData); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT( + VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkShaderEXT* pShaders); + +static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT( + VkDevice device, + VkShaderEXT shader, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT( + VkDevice device, + VkShaderEXT shader, + size_t* pDataSize, + void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT( + VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits* pStages, + const VkShaderEXT* pShaders); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT( + VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( + VkDevice device, + VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties); + + + + + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV( + VkDevice device, + VkSwapchainKHR swapchain, + const VkLatencySleepModeInfoNV* pSleepModeInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV( + VkDevice device, + VkSwapchainKHR swapchain, + const VkLatencySleepInfoNV* pSleepInfo); + +static VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV( + VkDevice device, + VkSwapchainKHR swapchain, + const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); + +static VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV( + VkDevice device, + VkSwapchainKHR swapchain, + VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); + +static VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV( + VkQueue queue, + const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT( + VkCommandBuffer commandBuffer, + VkImageAspectFlags aspectMask); + +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX( + VkDevice device, + const struct _screen_buffer* buffer, + VkScreenBufferPropertiesQNX* pProperties); +#endif /* VK_USE_PLATFORM_SCREEN_QNX */ + + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer); + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); + +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT( + VkDevice device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT( + VkDevice device, + const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectExecutionSetEXT* pIndirectExecutionSet); + +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); + +static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure); + +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR( + VkDevice device, + VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkDeviceAddress* pIndirectDeviceAddresses, + const uint32_t* pIndirectStrides, + const uint32_t* const* ppMaxPrimitiveCounts); + +static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR( + VkDevice device, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR( + VkDevice device, + const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR( + VkDevice device, + const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); + +static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); + + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress); + +static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t group, + VkShaderGroupShaderKHR groupShader); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR( + VkCommandBuffer commandBuffer, + uint32_t pipelineStackSize); + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +// Map of all APIs to be intercepted by this layer +static const std::unordered_map name_to_funcptr_map = { + {"vkCreateInstance", (void*)CreateInstance}, + {"vkDestroyInstance", (void*)DestroyInstance}, + {"vkEnumeratePhysicalDevices", (void*)EnumeratePhysicalDevices}, + {"vkGetPhysicalDeviceFeatures", (void*)GetPhysicalDeviceFeatures}, + {"vkGetPhysicalDeviceFormatProperties", (void*)GetPhysicalDeviceFormatProperties}, + {"vkGetPhysicalDeviceImageFormatProperties", (void*)GetPhysicalDeviceImageFormatProperties}, + {"vkGetPhysicalDeviceProperties", (void*)GetPhysicalDeviceProperties}, + {"vkGetPhysicalDeviceQueueFamilyProperties", (void*)GetPhysicalDeviceQueueFamilyProperties}, + {"vkGetPhysicalDeviceMemoryProperties", (void*)GetPhysicalDeviceMemoryProperties}, + {"vkGetInstanceProcAddr", (void*)GetInstanceProcAddr}, + {"vkGetDeviceProcAddr", (void*)GetDeviceProcAddr}, + {"vkCreateDevice", (void*)CreateDevice}, + {"vkDestroyDevice", (void*)DestroyDevice}, + {"vkEnumerateInstanceExtensionProperties", (void*)EnumerateInstanceExtensionProperties}, + {"vkEnumerateDeviceExtensionProperties", (void*)EnumerateDeviceExtensionProperties}, + {"vkEnumerateInstanceLayerProperties", (void*)EnumerateInstanceLayerProperties}, + {"vkEnumerateDeviceLayerProperties", (void*)EnumerateDeviceLayerProperties}, + {"vkGetDeviceQueue", (void*)GetDeviceQueue}, + {"vkQueueSubmit", (void*)QueueSubmit}, + {"vkQueueWaitIdle", (void*)QueueWaitIdle}, + {"vkDeviceWaitIdle", (void*)DeviceWaitIdle}, + {"vkAllocateMemory", (void*)AllocateMemory}, + {"vkFreeMemory", (void*)FreeMemory}, + {"vkMapMemory", (void*)MapMemory}, + {"vkUnmapMemory", (void*)UnmapMemory}, + {"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges}, + {"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges}, + {"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment}, + {"vkBindBufferMemory", (void*)BindBufferMemory}, + {"vkBindImageMemory", (void*)BindImageMemory}, + {"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements}, + {"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements}, + {"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements}, + {"vkGetPhysicalDeviceSparseImageFormatProperties", (void*)GetPhysicalDeviceSparseImageFormatProperties}, + {"vkQueueBindSparse", (void*)QueueBindSparse}, + {"vkCreateFence", (void*)CreateFence}, + {"vkDestroyFence", (void*)DestroyFence}, + {"vkResetFences", (void*)ResetFences}, + {"vkGetFenceStatus", (void*)GetFenceStatus}, + {"vkWaitForFences", (void*)WaitForFences}, + {"vkCreateSemaphore", (void*)CreateSemaphore}, + {"vkDestroySemaphore", (void*)DestroySemaphore}, + {"vkCreateEvent", (void*)CreateEvent}, + {"vkDestroyEvent", (void*)DestroyEvent}, + {"vkGetEventStatus", (void*)GetEventStatus}, + {"vkSetEvent", (void*)SetEvent}, + {"vkResetEvent", (void*)ResetEvent}, + {"vkCreateQueryPool", (void*)CreateQueryPool}, + {"vkDestroyQueryPool", (void*)DestroyQueryPool}, + {"vkGetQueryPoolResults", (void*)GetQueryPoolResults}, + {"vkCreateBuffer", (void*)CreateBuffer}, + {"vkDestroyBuffer", (void*)DestroyBuffer}, + {"vkCreateBufferView", (void*)CreateBufferView}, + {"vkDestroyBufferView", (void*)DestroyBufferView}, + {"vkCreateImage", (void*)CreateImage}, + {"vkDestroyImage", (void*)DestroyImage}, + {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout}, + {"vkCreateImageView", (void*)CreateImageView}, + {"vkDestroyImageView", (void*)DestroyImageView}, + {"vkCreateShaderModule", (void*)CreateShaderModule}, + {"vkDestroyShaderModule", (void*)DestroyShaderModule}, + {"vkCreatePipelineCache", (void*)CreatePipelineCache}, + {"vkDestroyPipelineCache", (void*)DestroyPipelineCache}, + {"vkGetPipelineCacheData", (void*)GetPipelineCacheData}, + {"vkMergePipelineCaches", (void*)MergePipelineCaches}, + {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines}, + {"vkCreateComputePipelines", (void*)CreateComputePipelines}, + {"vkDestroyPipeline", (void*)DestroyPipeline}, + {"vkCreatePipelineLayout", (void*)CreatePipelineLayout}, + {"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout}, + {"vkCreateSampler", (void*)CreateSampler}, + {"vkDestroySampler", (void*)DestroySampler}, + {"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout}, + {"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout}, + {"vkCreateDescriptorPool", (void*)CreateDescriptorPool}, + {"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool}, + {"vkResetDescriptorPool", (void*)ResetDescriptorPool}, + {"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets}, + {"vkFreeDescriptorSets", (void*)FreeDescriptorSets}, + {"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets}, + {"vkCreateFramebuffer", (void*)CreateFramebuffer}, + {"vkDestroyFramebuffer", (void*)DestroyFramebuffer}, + {"vkCreateRenderPass", (void*)CreateRenderPass}, + {"vkDestroyRenderPass", (void*)DestroyRenderPass}, + {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity}, + {"vkCreateCommandPool", (void*)CreateCommandPool}, + {"vkDestroyCommandPool", (void*)DestroyCommandPool}, + {"vkResetCommandPool", (void*)ResetCommandPool}, + {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers}, + {"vkFreeCommandBuffers", (void*)FreeCommandBuffers}, + {"vkBeginCommandBuffer", (void*)BeginCommandBuffer}, + {"vkEndCommandBuffer", (void*)EndCommandBuffer}, + {"vkResetCommandBuffer", (void*)ResetCommandBuffer}, + {"vkCmdBindPipeline", (void*)CmdBindPipeline}, + {"vkCmdSetViewport", (void*)CmdSetViewport}, + {"vkCmdSetScissor", (void*)CmdSetScissor}, + {"vkCmdSetLineWidth", (void*)CmdSetLineWidth}, + {"vkCmdSetDepthBias", (void*)CmdSetDepthBias}, + {"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants}, + {"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds}, + {"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask}, + {"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask}, + {"vkCmdSetStencilReference", (void*)CmdSetStencilReference}, + {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets}, + {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer}, + {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers}, + {"vkCmdDraw", (void*)CmdDraw}, + {"vkCmdDrawIndexed", (void*)CmdDrawIndexed}, + {"vkCmdDrawIndirect", (void*)CmdDrawIndirect}, + {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect}, + {"vkCmdDispatch", (void*)CmdDispatch}, + {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect}, + {"vkCmdCopyBuffer", (void*)CmdCopyBuffer}, + {"vkCmdCopyImage", (void*)CmdCopyImage}, + {"vkCmdBlitImage", (void*)CmdBlitImage}, + {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage}, + {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer}, + {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer}, + {"vkCmdFillBuffer", (void*)CmdFillBuffer}, + {"vkCmdClearColorImage", (void*)CmdClearColorImage}, + {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage}, + {"vkCmdClearAttachments", (void*)CmdClearAttachments}, + {"vkCmdResolveImage", (void*)CmdResolveImage}, + {"vkCmdSetEvent", (void*)CmdSetEvent}, + {"vkCmdResetEvent", (void*)CmdResetEvent}, + {"vkCmdWaitEvents", (void*)CmdWaitEvents}, + {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier}, + {"vkCmdBeginQuery", (void*)CmdBeginQuery}, + {"vkCmdEndQuery", (void*)CmdEndQuery}, + {"vkCmdResetQueryPool", (void*)CmdResetQueryPool}, + {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp}, + {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults}, + {"vkCmdPushConstants", (void*)CmdPushConstants}, + {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass}, + {"vkCmdNextSubpass", (void*)CmdNextSubpass}, + {"vkCmdEndRenderPass", (void*)CmdEndRenderPass}, + {"vkCmdExecuteCommands", (void*)CmdExecuteCommands}, + {"vkEnumerateInstanceVersion", (void*)EnumerateInstanceVersion}, + {"vkBindBufferMemory2", (void*)BindBufferMemory2}, + {"vkBindImageMemory2", (void*)BindImageMemory2}, + {"vkGetDeviceGroupPeerMemoryFeatures", (void*)GetDeviceGroupPeerMemoryFeatures}, + {"vkCmdSetDeviceMask", (void*)CmdSetDeviceMask}, + {"vkCmdDispatchBase", (void*)CmdDispatchBase}, + {"vkEnumeratePhysicalDeviceGroups", (void*)EnumeratePhysicalDeviceGroups}, + {"vkGetImageMemoryRequirements2", (void*)GetImageMemoryRequirements2}, + {"vkGetBufferMemoryRequirements2", (void*)GetBufferMemoryRequirements2}, + {"vkGetImageSparseMemoryRequirements2", (void*)GetImageSparseMemoryRequirements2}, + {"vkGetPhysicalDeviceFeatures2", (void*)GetPhysicalDeviceFeatures2}, + {"vkGetPhysicalDeviceProperties2", (void*)GetPhysicalDeviceProperties2}, + {"vkGetPhysicalDeviceFormatProperties2", (void*)GetPhysicalDeviceFormatProperties2}, + {"vkGetPhysicalDeviceImageFormatProperties2", (void*)GetPhysicalDeviceImageFormatProperties2}, + {"vkGetPhysicalDeviceQueueFamilyProperties2", (void*)GetPhysicalDeviceQueueFamilyProperties2}, + {"vkGetPhysicalDeviceMemoryProperties2", (void*)GetPhysicalDeviceMemoryProperties2}, + {"vkGetPhysicalDeviceSparseImageFormatProperties2", (void*)GetPhysicalDeviceSparseImageFormatProperties2}, + {"vkTrimCommandPool", (void*)TrimCommandPool}, + {"vkGetDeviceQueue2", (void*)GetDeviceQueue2}, + {"vkCreateSamplerYcbcrConversion", (void*)CreateSamplerYcbcrConversion}, + {"vkDestroySamplerYcbcrConversion", (void*)DestroySamplerYcbcrConversion}, + {"vkCreateDescriptorUpdateTemplate", (void*)CreateDescriptorUpdateTemplate}, + {"vkDestroyDescriptorUpdateTemplate", (void*)DestroyDescriptorUpdateTemplate}, + {"vkUpdateDescriptorSetWithTemplate", (void*)UpdateDescriptorSetWithTemplate}, + {"vkGetPhysicalDeviceExternalBufferProperties", (void*)GetPhysicalDeviceExternalBufferProperties}, + {"vkGetPhysicalDeviceExternalFenceProperties", (void*)GetPhysicalDeviceExternalFenceProperties}, + {"vkGetPhysicalDeviceExternalSemaphoreProperties", (void*)GetPhysicalDeviceExternalSemaphoreProperties}, + {"vkGetDescriptorSetLayoutSupport", (void*)GetDescriptorSetLayoutSupport}, + {"vkCmdDrawIndirectCount", (void*)CmdDrawIndirectCount}, + {"vkCmdDrawIndexedIndirectCount", (void*)CmdDrawIndexedIndirectCount}, + {"vkCreateRenderPass2", (void*)CreateRenderPass2}, + {"vkCmdBeginRenderPass2", (void*)CmdBeginRenderPass2}, + {"vkCmdNextSubpass2", (void*)CmdNextSubpass2}, + {"vkCmdEndRenderPass2", (void*)CmdEndRenderPass2}, + {"vkResetQueryPool", (void*)ResetQueryPool}, + {"vkGetSemaphoreCounterValue", (void*)GetSemaphoreCounterValue}, + {"vkWaitSemaphores", (void*)WaitSemaphores}, + {"vkSignalSemaphore", (void*)SignalSemaphore}, + {"vkGetBufferDeviceAddress", (void*)GetBufferDeviceAddress}, + {"vkGetBufferOpaqueCaptureAddress", (void*)GetBufferOpaqueCaptureAddress}, + {"vkGetDeviceMemoryOpaqueCaptureAddress", (void*)GetDeviceMemoryOpaqueCaptureAddress}, + {"vkGetPhysicalDeviceToolProperties", (void*)GetPhysicalDeviceToolProperties}, + {"vkCreatePrivateDataSlot", (void*)CreatePrivateDataSlot}, + {"vkDestroyPrivateDataSlot", (void*)DestroyPrivateDataSlot}, + {"vkSetPrivateData", (void*)SetPrivateData}, + {"vkGetPrivateData", (void*)GetPrivateData}, + {"vkCmdSetEvent2", (void*)CmdSetEvent2}, + {"vkCmdResetEvent2", (void*)CmdResetEvent2}, + {"vkCmdWaitEvents2", (void*)CmdWaitEvents2}, + {"vkCmdPipelineBarrier2", (void*)CmdPipelineBarrier2}, + {"vkCmdWriteTimestamp2", (void*)CmdWriteTimestamp2}, + {"vkQueueSubmit2", (void*)QueueSubmit2}, + {"vkCmdCopyBuffer2", (void*)CmdCopyBuffer2}, + {"vkCmdCopyImage2", (void*)CmdCopyImage2}, + {"vkCmdCopyBufferToImage2", (void*)CmdCopyBufferToImage2}, + {"vkCmdCopyImageToBuffer2", (void*)CmdCopyImageToBuffer2}, + {"vkCmdBlitImage2", (void*)CmdBlitImage2}, + {"vkCmdResolveImage2", (void*)CmdResolveImage2}, + {"vkCmdBeginRendering", (void*)CmdBeginRendering}, + {"vkCmdEndRendering", (void*)CmdEndRendering}, + {"vkCmdSetCullMode", (void*)CmdSetCullMode}, + {"vkCmdSetFrontFace", (void*)CmdSetFrontFace}, + {"vkCmdSetPrimitiveTopology", (void*)CmdSetPrimitiveTopology}, + {"vkCmdSetViewportWithCount", (void*)CmdSetViewportWithCount}, + {"vkCmdSetScissorWithCount", (void*)CmdSetScissorWithCount}, + {"vkCmdBindVertexBuffers2", (void*)CmdBindVertexBuffers2}, + {"vkCmdSetDepthTestEnable", (void*)CmdSetDepthTestEnable}, + {"vkCmdSetDepthWriteEnable", (void*)CmdSetDepthWriteEnable}, + {"vkCmdSetDepthCompareOp", (void*)CmdSetDepthCompareOp}, + {"vkCmdSetDepthBoundsTestEnable", (void*)CmdSetDepthBoundsTestEnable}, + {"vkCmdSetStencilTestEnable", (void*)CmdSetStencilTestEnable}, + {"vkCmdSetStencilOp", (void*)CmdSetStencilOp}, + {"vkCmdSetRasterizerDiscardEnable", (void*)CmdSetRasterizerDiscardEnable}, + {"vkCmdSetDepthBiasEnable", (void*)CmdSetDepthBiasEnable}, + {"vkCmdSetPrimitiveRestartEnable", (void*)CmdSetPrimitiveRestartEnable}, + {"vkGetDeviceBufferMemoryRequirements", (void*)GetDeviceBufferMemoryRequirements}, + {"vkGetDeviceImageMemoryRequirements", (void*)GetDeviceImageMemoryRequirements}, + {"vkGetDeviceImageSparseMemoryRequirements", (void*)GetDeviceImageSparseMemoryRequirements}, + {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR}, + {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR}, + {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR}, + {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR}, + {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR}, + {"vkCreateSwapchainKHR", (void*)CreateSwapchainKHR}, + {"vkDestroySwapchainKHR", (void*)DestroySwapchainKHR}, + {"vkGetSwapchainImagesKHR", (void*)GetSwapchainImagesKHR}, + {"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR}, + {"vkQueuePresentKHR", (void*)QueuePresentKHR}, + {"vkGetDeviceGroupPresentCapabilitiesKHR", (void*)GetDeviceGroupPresentCapabilitiesKHR}, + {"vkGetDeviceGroupSurfacePresentModesKHR", (void*)GetDeviceGroupSurfacePresentModesKHR}, + {"vkGetPhysicalDevicePresentRectanglesKHR", (void*)GetPhysicalDevicePresentRectanglesKHR}, + {"vkAcquireNextImage2KHR", (void*)AcquireNextImage2KHR}, + {"vkGetPhysicalDeviceDisplayPropertiesKHR", (void*)GetPhysicalDeviceDisplayPropertiesKHR}, + {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", (void*)GetPhysicalDeviceDisplayPlanePropertiesKHR}, + {"vkGetDisplayPlaneSupportedDisplaysKHR", (void*)GetDisplayPlaneSupportedDisplaysKHR}, + {"vkGetDisplayModePropertiesKHR", (void*)GetDisplayModePropertiesKHR}, + {"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR}, + {"vkGetDisplayPlaneCapabilitiesKHR", (void*)GetDisplayPlaneCapabilitiesKHR}, + {"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR}, + {"vkCreateSharedSwapchainsKHR", (void*)CreateSharedSwapchainsKHR}, +#ifdef VK_USE_PLATFORM_XLIB_KHR + {"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_XLIB_KHR + {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (void*)GetPhysicalDeviceXlibPresentationSupportKHR}, +#endif +#ifdef VK_USE_PLATFORM_XCB_KHR + {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_XCB_KHR + {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (void*)GetPhysicalDeviceXcbPresentationSupportKHR}, +#endif +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + {"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (void*)GetPhysicalDeviceWaylandPresentationSupportKHR}, +#endif +#ifdef VK_USE_PLATFORM_ANDROID_KHR + {"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void*)GetPhysicalDeviceWin32PresentationSupportKHR}, +#endif + {"vkGetPhysicalDeviceVideoCapabilitiesKHR", (void*)GetPhysicalDeviceVideoCapabilitiesKHR}, + {"vkGetPhysicalDeviceVideoFormatPropertiesKHR", (void*)GetPhysicalDeviceVideoFormatPropertiesKHR}, + {"vkCreateVideoSessionKHR", (void*)CreateVideoSessionKHR}, + {"vkDestroyVideoSessionKHR", (void*)DestroyVideoSessionKHR}, + {"vkGetVideoSessionMemoryRequirementsKHR", (void*)GetVideoSessionMemoryRequirementsKHR}, + {"vkBindVideoSessionMemoryKHR", (void*)BindVideoSessionMemoryKHR}, + {"vkCreateVideoSessionParametersKHR", (void*)CreateVideoSessionParametersKHR}, + {"vkUpdateVideoSessionParametersKHR", (void*)UpdateVideoSessionParametersKHR}, + {"vkDestroyVideoSessionParametersKHR", (void*)DestroyVideoSessionParametersKHR}, + {"vkCmdBeginVideoCodingKHR", (void*)CmdBeginVideoCodingKHR}, + {"vkCmdEndVideoCodingKHR", (void*)CmdEndVideoCodingKHR}, + {"vkCmdControlVideoCodingKHR", (void*)CmdControlVideoCodingKHR}, + {"vkCmdDecodeVideoKHR", (void*)CmdDecodeVideoKHR}, + {"vkCmdBeginRenderingKHR", (void*)CmdBeginRenderingKHR}, + {"vkCmdEndRenderingKHR", (void*)CmdEndRenderingKHR}, + {"vkGetPhysicalDeviceFeatures2KHR", (void*)GetPhysicalDeviceFeatures2KHR}, + {"vkGetPhysicalDeviceProperties2KHR", (void*)GetPhysicalDeviceProperties2KHR}, + {"vkGetPhysicalDeviceFormatProperties2KHR", (void*)GetPhysicalDeviceFormatProperties2KHR}, + {"vkGetPhysicalDeviceImageFormatProperties2KHR", (void*)GetPhysicalDeviceImageFormatProperties2KHR}, + {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void*)GetPhysicalDeviceQueueFamilyProperties2KHR}, + {"vkGetPhysicalDeviceMemoryProperties2KHR", (void*)GetPhysicalDeviceMemoryProperties2KHR}, + {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (void*)GetPhysicalDeviceSparseImageFormatProperties2KHR}, + {"vkGetDeviceGroupPeerMemoryFeaturesKHR", (void*)GetDeviceGroupPeerMemoryFeaturesKHR}, + {"vkCmdSetDeviceMaskKHR", (void*)CmdSetDeviceMaskKHR}, + {"vkCmdDispatchBaseKHR", (void*)CmdDispatchBaseKHR}, + {"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR}, + {"vkEnumeratePhysicalDeviceGroupsKHR", (void*)EnumeratePhysicalDeviceGroupsKHR}, + {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (void*)GetPhysicalDeviceExternalBufferPropertiesKHR}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR}, +#endif + {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR}, + {"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR}, + {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR}, +#endif + {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR}, + {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR}, + {"vkCmdPushDescriptorSetKHR", (void*)CmdPushDescriptorSetKHR}, + {"vkCmdPushDescriptorSetWithTemplateKHR", (void*)CmdPushDescriptorSetWithTemplateKHR}, + {"vkCreateDescriptorUpdateTemplateKHR", (void*)CreateDescriptorUpdateTemplateKHR}, + {"vkDestroyDescriptorUpdateTemplateKHR", (void*)DestroyDescriptorUpdateTemplateKHR}, + {"vkUpdateDescriptorSetWithTemplateKHR", (void*)UpdateDescriptorSetWithTemplateKHR}, + {"vkCreateRenderPass2KHR", (void*)CreateRenderPass2KHR}, + {"vkCmdBeginRenderPass2KHR", (void*)CmdBeginRenderPass2KHR}, + {"vkCmdNextSubpass2KHR", (void*)CmdNextSubpass2KHR}, + {"vkCmdEndRenderPass2KHR", (void*)CmdEndRenderPass2KHR}, + {"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR}, + {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (void*)GetPhysicalDeviceExternalFencePropertiesKHR}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR}, +#endif + {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR}, + {"vkGetFenceFdKHR", (void*)GetFenceFdKHR}, + {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR}, + {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", (void*)GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR}, + {"vkAcquireProfilingLockKHR", (void*)AcquireProfilingLockKHR}, + {"vkReleaseProfilingLockKHR", (void*)ReleaseProfilingLockKHR}, + {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void*)GetPhysicalDeviceSurfaceCapabilities2KHR}, + {"vkGetPhysicalDeviceSurfaceFormats2KHR", (void*)GetPhysicalDeviceSurfaceFormats2KHR}, + {"vkGetPhysicalDeviceDisplayProperties2KHR", (void*)GetPhysicalDeviceDisplayProperties2KHR}, + {"vkGetPhysicalDeviceDisplayPlaneProperties2KHR", (void*)GetPhysicalDeviceDisplayPlaneProperties2KHR}, + {"vkGetDisplayModeProperties2KHR", (void*)GetDisplayModeProperties2KHR}, + {"vkGetDisplayPlaneCapabilities2KHR", (void*)GetDisplayPlaneCapabilities2KHR}, + {"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR}, + {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR}, + {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR}, + {"vkCreateSamplerYcbcrConversionKHR", (void*)CreateSamplerYcbcrConversionKHR}, + {"vkDestroySamplerYcbcrConversionKHR", (void*)DestroySamplerYcbcrConversionKHR}, + {"vkBindBufferMemory2KHR", (void*)BindBufferMemory2KHR}, + {"vkBindImageMemory2KHR", (void*)BindImageMemory2KHR}, + {"vkGetDescriptorSetLayoutSupportKHR", (void*)GetDescriptorSetLayoutSupportKHR}, + {"vkCmdDrawIndirectCountKHR", (void*)CmdDrawIndirectCountKHR}, + {"vkCmdDrawIndexedIndirectCountKHR", (void*)CmdDrawIndexedIndirectCountKHR}, + {"vkGetSemaphoreCounterValueKHR", (void*)GetSemaphoreCounterValueKHR}, + {"vkWaitSemaphoresKHR", (void*)WaitSemaphoresKHR}, + {"vkSignalSemaphoreKHR", (void*)SignalSemaphoreKHR}, + {"vkGetPhysicalDeviceFragmentShadingRatesKHR", (void*)GetPhysicalDeviceFragmentShadingRatesKHR}, + {"vkCmdSetFragmentShadingRateKHR", (void*)CmdSetFragmentShadingRateKHR}, + {"vkCmdSetRenderingAttachmentLocationsKHR", (void*)CmdSetRenderingAttachmentLocationsKHR}, + {"vkCmdSetRenderingInputAttachmentIndicesKHR", (void*)CmdSetRenderingInputAttachmentIndicesKHR}, + {"vkWaitForPresentKHR", (void*)WaitForPresentKHR}, + {"vkGetBufferDeviceAddressKHR", (void*)GetBufferDeviceAddressKHR}, + {"vkGetBufferOpaqueCaptureAddressKHR", (void*)GetBufferOpaqueCaptureAddressKHR}, + {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", (void*)GetDeviceMemoryOpaqueCaptureAddressKHR}, + {"vkCreateDeferredOperationKHR", (void*)CreateDeferredOperationKHR}, + {"vkDestroyDeferredOperationKHR", (void*)DestroyDeferredOperationKHR}, + {"vkGetDeferredOperationMaxConcurrencyKHR", (void*)GetDeferredOperationMaxConcurrencyKHR}, + {"vkGetDeferredOperationResultKHR", (void*)GetDeferredOperationResultKHR}, + {"vkDeferredOperationJoinKHR", (void*)DeferredOperationJoinKHR}, + {"vkGetPipelineExecutablePropertiesKHR", (void*)GetPipelineExecutablePropertiesKHR}, + {"vkGetPipelineExecutableStatisticsKHR", (void*)GetPipelineExecutableStatisticsKHR}, + {"vkGetPipelineExecutableInternalRepresentationsKHR", (void*)GetPipelineExecutableInternalRepresentationsKHR}, + {"vkMapMemory2KHR", (void*)MapMemory2KHR}, + {"vkUnmapMemory2KHR", (void*)UnmapMemory2KHR}, + {"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR", (void*)GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR}, + {"vkGetEncodedVideoSessionParametersKHR", (void*)GetEncodedVideoSessionParametersKHR}, + {"vkCmdEncodeVideoKHR", (void*)CmdEncodeVideoKHR}, + {"vkCmdSetEvent2KHR", (void*)CmdSetEvent2KHR}, + {"vkCmdResetEvent2KHR", (void*)CmdResetEvent2KHR}, + {"vkCmdWaitEvents2KHR", (void*)CmdWaitEvents2KHR}, + {"vkCmdPipelineBarrier2KHR", (void*)CmdPipelineBarrier2KHR}, + {"vkCmdWriteTimestamp2KHR", (void*)CmdWriteTimestamp2KHR}, + {"vkQueueSubmit2KHR", (void*)QueueSubmit2KHR}, + {"vkCmdWriteBufferMarker2AMD", (void*)CmdWriteBufferMarker2AMD}, + {"vkGetQueueCheckpointData2NV", (void*)GetQueueCheckpointData2NV}, + {"vkCmdCopyBuffer2KHR", (void*)CmdCopyBuffer2KHR}, + {"vkCmdCopyImage2KHR", (void*)CmdCopyImage2KHR}, + {"vkCmdCopyBufferToImage2KHR", (void*)CmdCopyBufferToImage2KHR}, + {"vkCmdCopyImageToBuffer2KHR", (void*)CmdCopyImageToBuffer2KHR}, + {"vkCmdBlitImage2KHR", (void*)CmdBlitImage2KHR}, + {"vkCmdResolveImage2KHR", (void*)CmdResolveImage2KHR}, + {"vkCmdTraceRaysIndirect2KHR", (void*)CmdTraceRaysIndirect2KHR}, + {"vkGetDeviceBufferMemoryRequirementsKHR", (void*)GetDeviceBufferMemoryRequirementsKHR}, + {"vkGetDeviceImageMemoryRequirementsKHR", (void*)GetDeviceImageMemoryRequirementsKHR}, + {"vkGetDeviceImageSparseMemoryRequirementsKHR", (void*)GetDeviceImageSparseMemoryRequirementsKHR}, + {"vkCmdBindIndexBuffer2KHR", (void*)CmdBindIndexBuffer2KHR}, + {"vkGetRenderingAreaGranularityKHR", (void*)GetRenderingAreaGranularityKHR}, + {"vkGetDeviceImageSubresourceLayoutKHR", (void*)GetDeviceImageSubresourceLayoutKHR}, + {"vkGetImageSubresourceLayout2KHR", (void*)GetImageSubresourceLayout2KHR}, + {"vkCreatePipelineBinariesKHR", (void*)CreatePipelineBinariesKHR}, + {"vkDestroyPipelineBinaryKHR", (void*)DestroyPipelineBinaryKHR}, + {"vkGetPipelineKeyKHR", (void*)GetPipelineKeyKHR}, + {"vkGetPipelineBinaryDataKHR", (void*)GetPipelineBinaryDataKHR}, + {"vkReleaseCapturedPipelineDataKHR", (void*)ReleaseCapturedPipelineDataKHR}, + {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesKHR}, + {"vkCmdSetLineStippleKHR", (void*)CmdSetLineStippleKHR}, + {"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", (void*)GetPhysicalDeviceCalibrateableTimeDomainsKHR}, + {"vkGetCalibratedTimestampsKHR", (void*)GetCalibratedTimestampsKHR}, + {"vkCmdBindDescriptorSets2KHR", (void*)CmdBindDescriptorSets2KHR}, + {"vkCmdPushConstants2KHR", (void*)CmdPushConstants2KHR}, + {"vkCmdPushDescriptorSet2KHR", (void*)CmdPushDescriptorSet2KHR}, + {"vkCmdPushDescriptorSetWithTemplate2KHR", (void*)CmdPushDescriptorSetWithTemplate2KHR}, + {"vkCmdSetDescriptorBufferOffsets2EXT", (void*)CmdSetDescriptorBufferOffsets2EXT}, + {"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", (void*)CmdBindDescriptorBufferEmbeddedSamplers2EXT}, + {"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT}, + {"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT}, + {"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT}, + {"vkDebugMarkerSetObjectTagEXT", (void*)DebugMarkerSetObjectTagEXT}, + {"vkDebugMarkerSetObjectNameEXT", (void*)DebugMarkerSetObjectNameEXT}, + {"vkCmdDebugMarkerBeginEXT", (void*)CmdDebugMarkerBeginEXT}, + {"vkCmdDebugMarkerEndEXT", (void*)CmdDebugMarkerEndEXT}, + {"vkCmdDebugMarkerInsertEXT", (void*)CmdDebugMarkerInsertEXT}, + {"vkCmdBindTransformFeedbackBuffersEXT", (void*)CmdBindTransformFeedbackBuffersEXT}, + {"vkCmdBeginTransformFeedbackEXT", (void*)CmdBeginTransformFeedbackEXT}, + {"vkCmdEndTransformFeedbackEXT", (void*)CmdEndTransformFeedbackEXT}, + {"vkCmdBeginQueryIndexedEXT", (void*)CmdBeginQueryIndexedEXT}, + {"vkCmdEndQueryIndexedEXT", (void*)CmdEndQueryIndexedEXT}, + {"vkCmdDrawIndirectByteCountEXT", (void*)CmdDrawIndirectByteCountEXT}, + {"vkCreateCuModuleNVX", (void*)CreateCuModuleNVX}, + {"vkCreateCuFunctionNVX", (void*)CreateCuFunctionNVX}, + {"vkDestroyCuModuleNVX", (void*)DestroyCuModuleNVX}, + {"vkDestroyCuFunctionNVX", (void*)DestroyCuFunctionNVX}, + {"vkCmdCuLaunchKernelNVX", (void*)CmdCuLaunchKernelNVX}, + {"vkGetImageViewHandleNVX", (void*)GetImageViewHandleNVX}, + {"vkGetImageViewAddressNVX", (void*)GetImageViewAddressNVX}, + {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD}, + {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD}, + {"vkGetShaderInfoAMD", (void*)GetShaderInfoAMD}, +#ifdef VK_USE_PLATFORM_GGP + {"vkCreateStreamDescriptorSurfaceGGP", (void*)CreateStreamDescriptorSurfaceGGP}, +#endif + {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", (void*)GetPhysicalDeviceExternalImageFormatPropertiesNV}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV}, +#endif +#ifdef VK_USE_PLATFORM_VI_NN + {"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN}, +#endif + {"vkCmdBeginConditionalRenderingEXT", (void*)CmdBeginConditionalRenderingEXT}, + {"vkCmdEndConditionalRenderingEXT", (void*)CmdEndConditionalRenderingEXT}, + {"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV}, + {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT}, +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT}, +#endif +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + {"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT}, +#endif + {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT}, + {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT}, + {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT}, + {"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT}, + {"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT}, + {"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE}, + {"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE}, + {"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT}, + {"vkCmdSetDiscardRectangleEnableEXT", (void*)CmdSetDiscardRectangleEnableEXT}, + {"vkCmdSetDiscardRectangleModeEXT", (void*)CmdSetDiscardRectangleModeEXT}, + {"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT}, +#ifdef VK_USE_PLATFORM_IOS_MVK + {"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK}, +#endif +#ifdef VK_USE_PLATFORM_MACOS_MVK + {"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK}, +#endif + {"vkSetDebugUtilsObjectNameEXT", (void*)SetDebugUtilsObjectNameEXT}, + {"vkSetDebugUtilsObjectTagEXT", (void*)SetDebugUtilsObjectTagEXT}, + {"vkQueueBeginDebugUtilsLabelEXT", (void*)QueueBeginDebugUtilsLabelEXT}, + {"vkQueueEndDebugUtilsLabelEXT", (void*)QueueEndDebugUtilsLabelEXT}, + {"vkQueueInsertDebugUtilsLabelEXT", (void*)QueueInsertDebugUtilsLabelEXT}, + {"vkCmdBeginDebugUtilsLabelEXT", (void*)CmdBeginDebugUtilsLabelEXT}, + {"vkCmdEndDebugUtilsLabelEXT", (void*)CmdEndDebugUtilsLabelEXT}, + {"vkCmdInsertDebugUtilsLabelEXT", (void*)CmdInsertDebugUtilsLabelEXT}, + {"vkCreateDebugUtilsMessengerEXT", (void*)CreateDebugUtilsMessengerEXT}, + {"vkDestroyDebugUtilsMessengerEXT", (void*)DestroyDebugUtilsMessengerEXT}, + {"vkSubmitDebugUtilsMessageEXT", (void*)SubmitDebugUtilsMessageEXT}, +#ifdef VK_USE_PLATFORM_ANDROID_KHR + {"vkGetAndroidHardwareBufferPropertiesANDROID", (void*)GetAndroidHardwareBufferPropertiesANDROID}, +#endif +#ifdef VK_USE_PLATFORM_ANDROID_KHR + {"vkGetMemoryAndroidHardwareBufferANDROID", (void*)GetMemoryAndroidHardwareBufferANDROID}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkCreateExecutionGraphPipelinesAMDX", (void*)CreateExecutionGraphPipelinesAMDX}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkGetExecutionGraphPipelineScratchSizeAMDX", (void*)GetExecutionGraphPipelineScratchSizeAMDX}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkGetExecutionGraphPipelineNodeIndexAMDX", (void*)GetExecutionGraphPipelineNodeIndexAMDX}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkCmdInitializeGraphScratchMemoryAMDX", (void*)CmdInitializeGraphScratchMemoryAMDX}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkCmdDispatchGraphAMDX", (void*)CmdDispatchGraphAMDX}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkCmdDispatchGraphIndirectAMDX", (void*)CmdDispatchGraphIndirectAMDX}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkCmdDispatchGraphIndirectCountAMDX", (void*)CmdDispatchGraphIndirectCountAMDX}, +#endif + {"vkCmdSetSampleLocationsEXT", (void*)CmdSetSampleLocationsEXT}, + {"vkGetPhysicalDeviceMultisamplePropertiesEXT", (void*)GetPhysicalDeviceMultisamplePropertiesEXT}, + {"vkGetImageDrmFormatModifierPropertiesEXT", (void*)GetImageDrmFormatModifierPropertiesEXT}, + {"vkCreateValidationCacheEXT", (void*)CreateValidationCacheEXT}, + {"vkDestroyValidationCacheEXT", (void*)DestroyValidationCacheEXT}, + {"vkMergeValidationCachesEXT", (void*)MergeValidationCachesEXT}, + {"vkGetValidationCacheDataEXT", (void*)GetValidationCacheDataEXT}, + {"vkCmdBindShadingRateImageNV", (void*)CmdBindShadingRateImageNV}, + {"vkCmdSetViewportShadingRatePaletteNV", (void*)CmdSetViewportShadingRatePaletteNV}, + {"vkCmdSetCoarseSampleOrderNV", (void*)CmdSetCoarseSampleOrderNV}, + {"vkCreateAccelerationStructureNV", (void*)CreateAccelerationStructureNV}, + {"vkDestroyAccelerationStructureNV", (void*)DestroyAccelerationStructureNV}, + {"vkGetAccelerationStructureMemoryRequirementsNV", (void*)GetAccelerationStructureMemoryRequirementsNV}, + {"vkBindAccelerationStructureMemoryNV", (void*)BindAccelerationStructureMemoryNV}, + {"vkCmdBuildAccelerationStructureNV", (void*)CmdBuildAccelerationStructureNV}, + {"vkCmdCopyAccelerationStructureNV", (void*)CmdCopyAccelerationStructureNV}, + {"vkCmdTraceRaysNV", (void*)CmdTraceRaysNV}, + {"vkCreateRayTracingPipelinesNV", (void*)CreateRayTracingPipelinesNV}, + {"vkGetRayTracingShaderGroupHandlesKHR", (void*)GetRayTracingShaderGroupHandlesKHR}, + {"vkGetRayTracingShaderGroupHandlesNV", (void*)GetRayTracingShaderGroupHandlesNV}, + {"vkGetAccelerationStructureHandleNV", (void*)GetAccelerationStructureHandleNV}, + {"vkCmdWriteAccelerationStructuresPropertiesNV", (void*)CmdWriteAccelerationStructuresPropertiesNV}, + {"vkCompileDeferredNV", (void*)CompileDeferredNV}, + {"vkGetMemoryHostPointerPropertiesEXT", (void*)GetMemoryHostPointerPropertiesEXT}, + {"vkCmdWriteBufferMarkerAMD", (void*)CmdWriteBufferMarkerAMD}, + {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", (void*)GetPhysicalDeviceCalibrateableTimeDomainsEXT}, + {"vkGetCalibratedTimestampsEXT", (void*)GetCalibratedTimestampsEXT}, + {"vkCmdDrawMeshTasksNV", (void*)CmdDrawMeshTasksNV}, + {"vkCmdDrawMeshTasksIndirectNV", (void*)CmdDrawMeshTasksIndirectNV}, + {"vkCmdDrawMeshTasksIndirectCountNV", (void*)CmdDrawMeshTasksIndirectCountNV}, + {"vkCmdSetExclusiveScissorEnableNV", (void*)CmdSetExclusiveScissorEnableNV}, + {"vkCmdSetExclusiveScissorNV", (void*)CmdSetExclusiveScissorNV}, + {"vkCmdSetCheckpointNV", (void*)CmdSetCheckpointNV}, + {"vkGetQueueCheckpointDataNV", (void*)GetQueueCheckpointDataNV}, + {"vkInitializePerformanceApiINTEL", (void*)InitializePerformanceApiINTEL}, + {"vkUninitializePerformanceApiINTEL", (void*)UninitializePerformanceApiINTEL}, + {"vkCmdSetPerformanceMarkerINTEL", (void*)CmdSetPerformanceMarkerINTEL}, + {"vkCmdSetPerformanceStreamMarkerINTEL", (void*)CmdSetPerformanceStreamMarkerINTEL}, + {"vkCmdSetPerformanceOverrideINTEL", (void*)CmdSetPerformanceOverrideINTEL}, + {"vkAcquirePerformanceConfigurationINTEL", (void*)AcquirePerformanceConfigurationINTEL}, + {"vkReleasePerformanceConfigurationINTEL", (void*)ReleasePerformanceConfigurationINTEL}, + {"vkQueueSetPerformanceConfigurationINTEL", (void*)QueueSetPerformanceConfigurationINTEL}, + {"vkGetPerformanceParameterINTEL", (void*)GetPerformanceParameterINTEL}, + {"vkSetLocalDimmingAMD", (void*)SetLocalDimmingAMD}, +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkCreateImagePipeSurfaceFUCHSIA", (void*)CreateImagePipeSurfaceFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_METAL_EXT + {"vkCreateMetalSurfaceEXT", (void*)CreateMetalSurfaceEXT}, +#endif + {"vkGetBufferDeviceAddressEXT", (void*)GetBufferDeviceAddressEXT}, + {"vkGetPhysicalDeviceToolPropertiesEXT", (void*)GetPhysicalDeviceToolPropertiesEXT}, + {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesNV}, + {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", (void*)GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetPhysicalDeviceSurfacePresentModes2EXT", (void*)GetPhysicalDeviceSurfacePresentModes2EXT}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkAcquireFullScreenExclusiveModeEXT", (void*)AcquireFullScreenExclusiveModeEXT}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkReleaseFullScreenExclusiveModeEXT", (void*)ReleaseFullScreenExclusiveModeEXT}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetDeviceGroupSurfacePresentModes2EXT", (void*)GetDeviceGroupSurfacePresentModes2EXT}, +#endif + {"vkCreateHeadlessSurfaceEXT", (void*)CreateHeadlessSurfaceEXT}, + {"vkCmdSetLineStippleEXT", (void*)CmdSetLineStippleEXT}, + {"vkResetQueryPoolEXT", (void*)ResetQueryPoolEXT}, + {"vkCmdSetCullModeEXT", (void*)CmdSetCullModeEXT}, + {"vkCmdSetFrontFaceEXT", (void*)CmdSetFrontFaceEXT}, + {"vkCmdSetPrimitiveTopologyEXT", (void*)CmdSetPrimitiveTopologyEXT}, + {"vkCmdSetViewportWithCountEXT", (void*)CmdSetViewportWithCountEXT}, + {"vkCmdSetScissorWithCountEXT", (void*)CmdSetScissorWithCountEXT}, + {"vkCmdBindVertexBuffers2EXT", (void*)CmdBindVertexBuffers2EXT}, + {"vkCmdSetDepthTestEnableEXT", (void*)CmdSetDepthTestEnableEXT}, + {"vkCmdSetDepthWriteEnableEXT", (void*)CmdSetDepthWriteEnableEXT}, + {"vkCmdSetDepthCompareOpEXT", (void*)CmdSetDepthCompareOpEXT}, + {"vkCmdSetDepthBoundsTestEnableEXT", (void*)CmdSetDepthBoundsTestEnableEXT}, + {"vkCmdSetStencilTestEnableEXT", (void*)CmdSetStencilTestEnableEXT}, + {"vkCmdSetStencilOpEXT", (void*)CmdSetStencilOpEXT}, + {"vkCopyMemoryToImageEXT", (void*)CopyMemoryToImageEXT}, + {"vkCopyImageToMemoryEXT", (void*)CopyImageToMemoryEXT}, + {"vkCopyImageToImageEXT", (void*)CopyImageToImageEXT}, + {"vkTransitionImageLayoutEXT", (void*)TransitionImageLayoutEXT}, + {"vkGetImageSubresourceLayout2EXT", (void*)GetImageSubresourceLayout2EXT}, + {"vkReleaseSwapchainImagesEXT", (void*)ReleaseSwapchainImagesEXT}, + {"vkGetGeneratedCommandsMemoryRequirementsNV", (void*)GetGeneratedCommandsMemoryRequirementsNV}, + {"vkCmdPreprocessGeneratedCommandsNV", (void*)CmdPreprocessGeneratedCommandsNV}, + {"vkCmdExecuteGeneratedCommandsNV", (void*)CmdExecuteGeneratedCommandsNV}, + {"vkCmdBindPipelineShaderGroupNV", (void*)CmdBindPipelineShaderGroupNV}, + {"vkCreateIndirectCommandsLayoutNV", (void*)CreateIndirectCommandsLayoutNV}, + {"vkDestroyIndirectCommandsLayoutNV", (void*)DestroyIndirectCommandsLayoutNV}, + {"vkCmdSetDepthBias2EXT", (void*)CmdSetDepthBias2EXT}, + {"vkAcquireDrmDisplayEXT", (void*)AcquireDrmDisplayEXT}, + {"vkGetDrmDisplayEXT", (void*)GetDrmDisplayEXT}, + {"vkCreatePrivateDataSlotEXT", (void*)CreatePrivateDataSlotEXT}, + {"vkDestroyPrivateDataSlotEXT", (void*)DestroyPrivateDataSlotEXT}, + {"vkSetPrivateDataEXT", (void*)SetPrivateDataEXT}, + {"vkGetPrivateDataEXT", (void*)GetPrivateDataEXT}, + {"vkCreateCudaModuleNV", (void*)CreateCudaModuleNV}, + {"vkGetCudaModuleCacheNV", (void*)GetCudaModuleCacheNV}, + {"vkCreateCudaFunctionNV", (void*)CreateCudaFunctionNV}, + {"vkDestroyCudaModuleNV", (void*)DestroyCudaModuleNV}, + {"vkDestroyCudaFunctionNV", (void*)DestroyCudaFunctionNV}, + {"vkCmdCudaLaunchKernelNV", (void*)CmdCudaLaunchKernelNV}, +#ifdef VK_USE_PLATFORM_METAL_EXT + {"vkExportMetalObjectsEXT", (void*)ExportMetalObjectsEXT}, +#endif + {"vkGetDescriptorSetLayoutSizeEXT", (void*)GetDescriptorSetLayoutSizeEXT}, + {"vkGetDescriptorSetLayoutBindingOffsetEXT", (void*)GetDescriptorSetLayoutBindingOffsetEXT}, + {"vkGetDescriptorEXT", (void*)GetDescriptorEXT}, + {"vkCmdBindDescriptorBuffersEXT", (void*)CmdBindDescriptorBuffersEXT}, + {"vkCmdSetDescriptorBufferOffsetsEXT", (void*)CmdSetDescriptorBufferOffsetsEXT}, + {"vkCmdBindDescriptorBufferEmbeddedSamplersEXT", (void*)CmdBindDescriptorBufferEmbeddedSamplersEXT}, + {"vkGetBufferOpaqueCaptureDescriptorDataEXT", (void*)GetBufferOpaqueCaptureDescriptorDataEXT}, + {"vkGetImageOpaqueCaptureDescriptorDataEXT", (void*)GetImageOpaqueCaptureDescriptorDataEXT}, + {"vkGetImageViewOpaqueCaptureDescriptorDataEXT", (void*)GetImageViewOpaqueCaptureDescriptorDataEXT}, + {"vkGetSamplerOpaqueCaptureDescriptorDataEXT", (void*)GetSamplerOpaqueCaptureDescriptorDataEXT}, + {"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT", (void*)GetAccelerationStructureOpaqueCaptureDescriptorDataEXT}, + {"vkCmdSetFragmentShadingRateEnumNV", (void*)CmdSetFragmentShadingRateEnumNV}, + {"vkGetDeviceFaultInfoEXT", (void*)GetDeviceFaultInfoEXT}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkAcquireWinrtDisplayNV", (void*)AcquireWinrtDisplayNV}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetWinrtDisplayNV", (void*)GetWinrtDisplayNV}, +#endif +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT + {"vkCreateDirectFBSurfaceEXT", (void*)CreateDirectFBSurfaceEXT}, +#endif +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT + {"vkGetPhysicalDeviceDirectFBPresentationSupportEXT", (void*)GetPhysicalDeviceDirectFBPresentationSupportEXT}, +#endif + {"vkCmdSetVertexInputEXT", (void*)CmdSetVertexInputEXT}, +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkGetMemoryZirconHandleFUCHSIA", (void*)GetMemoryZirconHandleFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkGetMemoryZirconHandlePropertiesFUCHSIA", (void*)GetMemoryZirconHandlePropertiesFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkImportSemaphoreZirconHandleFUCHSIA", (void*)ImportSemaphoreZirconHandleFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkGetSemaphoreZirconHandleFUCHSIA", (void*)GetSemaphoreZirconHandleFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkCreateBufferCollectionFUCHSIA", (void*)CreateBufferCollectionFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkSetBufferCollectionImageConstraintsFUCHSIA", (void*)SetBufferCollectionImageConstraintsFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkSetBufferCollectionBufferConstraintsFUCHSIA", (void*)SetBufferCollectionBufferConstraintsFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkDestroyBufferCollectionFUCHSIA", (void*)DestroyBufferCollectionFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkGetBufferCollectionPropertiesFUCHSIA", (void*)GetBufferCollectionPropertiesFUCHSIA}, +#endif + {"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", (void*)GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI}, + {"vkCmdSubpassShadingHUAWEI", (void*)CmdSubpassShadingHUAWEI}, + {"vkCmdBindInvocationMaskHUAWEI", (void*)CmdBindInvocationMaskHUAWEI}, + {"vkGetMemoryRemoteAddressNV", (void*)GetMemoryRemoteAddressNV}, + {"vkGetPipelinePropertiesEXT", (void*)GetPipelinePropertiesEXT}, + {"vkCmdSetPatchControlPointsEXT", (void*)CmdSetPatchControlPointsEXT}, + {"vkCmdSetRasterizerDiscardEnableEXT", (void*)CmdSetRasterizerDiscardEnableEXT}, + {"vkCmdSetDepthBiasEnableEXT", (void*)CmdSetDepthBiasEnableEXT}, + {"vkCmdSetLogicOpEXT", (void*)CmdSetLogicOpEXT}, + {"vkCmdSetPrimitiveRestartEnableEXT", (void*)CmdSetPrimitiveRestartEnableEXT}, +#ifdef VK_USE_PLATFORM_SCREEN_QNX + {"vkCreateScreenSurfaceQNX", (void*)CreateScreenSurfaceQNX}, +#endif +#ifdef VK_USE_PLATFORM_SCREEN_QNX + {"vkGetPhysicalDeviceScreenPresentationSupportQNX", (void*)GetPhysicalDeviceScreenPresentationSupportQNX}, +#endif + {"vkCmdSetColorWriteEnableEXT", (void*)CmdSetColorWriteEnableEXT}, + {"vkCmdDrawMultiEXT", (void*)CmdDrawMultiEXT}, + {"vkCmdDrawMultiIndexedEXT", (void*)CmdDrawMultiIndexedEXT}, + {"vkCreateMicromapEXT", (void*)CreateMicromapEXT}, + {"vkDestroyMicromapEXT", (void*)DestroyMicromapEXT}, + {"vkCmdBuildMicromapsEXT", (void*)CmdBuildMicromapsEXT}, + {"vkBuildMicromapsEXT", (void*)BuildMicromapsEXT}, + {"vkCopyMicromapEXT", (void*)CopyMicromapEXT}, + {"vkCopyMicromapToMemoryEXT", (void*)CopyMicromapToMemoryEXT}, + {"vkCopyMemoryToMicromapEXT", (void*)CopyMemoryToMicromapEXT}, + {"vkWriteMicromapsPropertiesEXT", (void*)WriteMicromapsPropertiesEXT}, + {"vkCmdCopyMicromapEXT", (void*)CmdCopyMicromapEXT}, + {"vkCmdCopyMicromapToMemoryEXT", (void*)CmdCopyMicromapToMemoryEXT}, + {"vkCmdCopyMemoryToMicromapEXT", (void*)CmdCopyMemoryToMicromapEXT}, + {"vkCmdWriteMicromapsPropertiesEXT", (void*)CmdWriteMicromapsPropertiesEXT}, + {"vkGetDeviceMicromapCompatibilityEXT", (void*)GetDeviceMicromapCompatibilityEXT}, + {"vkGetMicromapBuildSizesEXT", (void*)GetMicromapBuildSizesEXT}, + {"vkCmdDrawClusterHUAWEI", (void*)CmdDrawClusterHUAWEI}, + {"vkCmdDrawClusterIndirectHUAWEI", (void*)CmdDrawClusterIndirectHUAWEI}, + {"vkSetDeviceMemoryPriorityEXT", (void*)SetDeviceMemoryPriorityEXT}, + {"vkGetDescriptorSetLayoutHostMappingInfoVALVE", (void*)GetDescriptorSetLayoutHostMappingInfoVALVE}, + {"vkGetDescriptorSetHostMappingVALVE", (void*)GetDescriptorSetHostMappingVALVE}, + {"vkCmdCopyMemoryIndirectNV", (void*)CmdCopyMemoryIndirectNV}, + {"vkCmdCopyMemoryToImageIndirectNV", (void*)CmdCopyMemoryToImageIndirectNV}, + {"vkCmdDecompressMemoryNV", (void*)CmdDecompressMemoryNV}, + {"vkCmdDecompressMemoryIndirectCountNV", (void*)CmdDecompressMemoryIndirectCountNV}, + {"vkGetPipelineIndirectMemoryRequirementsNV", (void*)GetPipelineIndirectMemoryRequirementsNV}, + {"vkCmdUpdatePipelineIndirectBufferNV", (void*)CmdUpdatePipelineIndirectBufferNV}, + {"vkGetPipelineIndirectDeviceAddressNV", (void*)GetPipelineIndirectDeviceAddressNV}, + {"vkCmdSetDepthClampEnableEXT", (void*)CmdSetDepthClampEnableEXT}, + {"vkCmdSetPolygonModeEXT", (void*)CmdSetPolygonModeEXT}, + {"vkCmdSetRasterizationSamplesEXT", (void*)CmdSetRasterizationSamplesEXT}, + {"vkCmdSetSampleMaskEXT", (void*)CmdSetSampleMaskEXT}, + {"vkCmdSetAlphaToCoverageEnableEXT", (void*)CmdSetAlphaToCoverageEnableEXT}, + {"vkCmdSetAlphaToOneEnableEXT", (void*)CmdSetAlphaToOneEnableEXT}, + {"vkCmdSetLogicOpEnableEXT", (void*)CmdSetLogicOpEnableEXT}, + {"vkCmdSetColorBlendEnableEXT", (void*)CmdSetColorBlendEnableEXT}, + {"vkCmdSetColorBlendEquationEXT", (void*)CmdSetColorBlendEquationEXT}, + {"vkCmdSetColorWriteMaskEXT", (void*)CmdSetColorWriteMaskEXT}, + {"vkCmdSetTessellationDomainOriginEXT", (void*)CmdSetTessellationDomainOriginEXT}, + {"vkCmdSetRasterizationStreamEXT", (void*)CmdSetRasterizationStreamEXT}, + {"vkCmdSetConservativeRasterizationModeEXT", (void*)CmdSetConservativeRasterizationModeEXT}, + {"vkCmdSetExtraPrimitiveOverestimationSizeEXT", (void*)CmdSetExtraPrimitiveOverestimationSizeEXT}, + {"vkCmdSetDepthClipEnableEXT", (void*)CmdSetDepthClipEnableEXT}, + {"vkCmdSetSampleLocationsEnableEXT", (void*)CmdSetSampleLocationsEnableEXT}, + {"vkCmdSetColorBlendAdvancedEXT", (void*)CmdSetColorBlendAdvancedEXT}, + {"vkCmdSetProvokingVertexModeEXT", (void*)CmdSetProvokingVertexModeEXT}, + {"vkCmdSetLineRasterizationModeEXT", (void*)CmdSetLineRasterizationModeEXT}, + {"vkCmdSetLineStippleEnableEXT", (void*)CmdSetLineStippleEnableEXT}, + {"vkCmdSetDepthClipNegativeOneToOneEXT", (void*)CmdSetDepthClipNegativeOneToOneEXT}, + {"vkCmdSetViewportWScalingEnableNV", (void*)CmdSetViewportWScalingEnableNV}, + {"vkCmdSetViewportSwizzleNV", (void*)CmdSetViewportSwizzleNV}, + {"vkCmdSetCoverageToColorEnableNV", (void*)CmdSetCoverageToColorEnableNV}, + {"vkCmdSetCoverageToColorLocationNV", (void*)CmdSetCoverageToColorLocationNV}, + {"vkCmdSetCoverageModulationModeNV", (void*)CmdSetCoverageModulationModeNV}, + {"vkCmdSetCoverageModulationTableEnableNV", (void*)CmdSetCoverageModulationTableEnableNV}, + {"vkCmdSetCoverageModulationTableNV", (void*)CmdSetCoverageModulationTableNV}, + {"vkCmdSetShadingRateImageEnableNV", (void*)CmdSetShadingRateImageEnableNV}, + {"vkCmdSetRepresentativeFragmentTestEnableNV", (void*)CmdSetRepresentativeFragmentTestEnableNV}, + {"vkCmdSetCoverageReductionModeNV", (void*)CmdSetCoverageReductionModeNV}, + {"vkGetShaderModuleIdentifierEXT", (void*)GetShaderModuleIdentifierEXT}, + {"vkGetShaderModuleCreateInfoIdentifierEXT", (void*)GetShaderModuleCreateInfoIdentifierEXT}, + {"vkGetPhysicalDeviceOpticalFlowImageFormatsNV", (void*)GetPhysicalDeviceOpticalFlowImageFormatsNV}, + {"vkCreateOpticalFlowSessionNV", (void*)CreateOpticalFlowSessionNV}, + {"vkDestroyOpticalFlowSessionNV", (void*)DestroyOpticalFlowSessionNV}, + {"vkBindOpticalFlowSessionImageNV", (void*)BindOpticalFlowSessionImageNV}, + {"vkCmdOpticalFlowExecuteNV", (void*)CmdOpticalFlowExecuteNV}, + {"vkAntiLagUpdateAMD", (void*)AntiLagUpdateAMD}, + {"vkCreateShadersEXT", (void*)CreateShadersEXT}, + {"vkDestroyShaderEXT", (void*)DestroyShaderEXT}, + {"vkGetShaderBinaryDataEXT", (void*)GetShaderBinaryDataEXT}, + {"vkCmdBindShadersEXT", (void*)CmdBindShadersEXT}, + {"vkCmdSetDepthClampRangeEXT", (void*)CmdSetDepthClampRangeEXT}, + {"vkGetFramebufferTilePropertiesQCOM", (void*)GetFramebufferTilePropertiesQCOM}, + {"vkGetDynamicRenderingTilePropertiesQCOM", (void*)GetDynamicRenderingTilePropertiesQCOM}, + {"vkSetLatencySleepModeNV", (void*)SetLatencySleepModeNV}, + {"vkLatencySleepNV", (void*)LatencySleepNV}, + {"vkSetLatencyMarkerNV", (void*)SetLatencyMarkerNV}, + {"vkGetLatencyTimingsNV", (void*)GetLatencyTimingsNV}, + {"vkQueueNotifyOutOfBandNV", (void*)QueueNotifyOutOfBandNV}, + {"vkCmdSetAttachmentFeedbackLoopEnableEXT", (void*)CmdSetAttachmentFeedbackLoopEnableEXT}, +#ifdef VK_USE_PLATFORM_SCREEN_QNX + {"vkGetScreenBufferPropertiesQNX", (void*)GetScreenBufferPropertiesQNX}, +#endif + {"vkGetGeneratedCommandsMemoryRequirementsEXT", (void*)GetGeneratedCommandsMemoryRequirementsEXT}, + {"vkCmdPreprocessGeneratedCommandsEXT", (void*)CmdPreprocessGeneratedCommandsEXT}, + {"vkCmdExecuteGeneratedCommandsEXT", (void*)CmdExecuteGeneratedCommandsEXT}, + {"vkCreateIndirectCommandsLayoutEXT", (void*)CreateIndirectCommandsLayoutEXT}, + {"vkDestroyIndirectCommandsLayoutEXT", (void*)DestroyIndirectCommandsLayoutEXT}, + {"vkCreateIndirectExecutionSetEXT", (void*)CreateIndirectExecutionSetEXT}, + {"vkDestroyIndirectExecutionSetEXT", (void*)DestroyIndirectExecutionSetEXT}, + {"vkUpdateIndirectExecutionSetPipelineEXT", (void*)UpdateIndirectExecutionSetPipelineEXT}, + {"vkUpdateIndirectExecutionSetShaderEXT", (void*)UpdateIndirectExecutionSetShaderEXT}, + {"vkCreateAccelerationStructureKHR", (void*)CreateAccelerationStructureKHR}, + {"vkDestroyAccelerationStructureKHR", (void*)DestroyAccelerationStructureKHR}, + {"vkCmdBuildAccelerationStructuresKHR", (void*)CmdBuildAccelerationStructuresKHR}, + {"vkCmdBuildAccelerationStructuresIndirectKHR", (void*)CmdBuildAccelerationStructuresIndirectKHR}, + {"vkBuildAccelerationStructuresKHR", (void*)BuildAccelerationStructuresKHR}, + {"vkCopyAccelerationStructureKHR", (void*)CopyAccelerationStructureKHR}, + {"vkCopyAccelerationStructureToMemoryKHR", (void*)CopyAccelerationStructureToMemoryKHR}, + {"vkCopyMemoryToAccelerationStructureKHR", (void*)CopyMemoryToAccelerationStructureKHR}, + {"vkWriteAccelerationStructuresPropertiesKHR", (void*)WriteAccelerationStructuresPropertiesKHR}, + {"vkCmdCopyAccelerationStructureKHR", (void*)CmdCopyAccelerationStructureKHR}, + {"vkCmdCopyAccelerationStructureToMemoryKHR", (void*)CmdCopyAccelerationStructureToMemoryKHR}, + {"vkCmdCopyMemoryToAccelerationStructureKHR", (void*)CmdCopyMemoryToAccelerationStructureKHR}, + {"vkGetAccelerationStructureDeviceAddressKHR", (void*)GetAccelerationStructureDeviceAddressKHR}, + {"vkCmdWriteAccelerationStructuresPropertiesKHR", (void*)CmdWriteAccelerationStructuresPropertiesKHR}, + {"vkGetDeviceAccelerationStructureCompatibilityKHR", (void*)GetDeviceAccelerationStructureCompatibilityKHR}, + {"vkGetAccelerationStructureBuildSizesKHR", (void*)GetAccelerationStructureBuildSizesKHR}, + {"vkCmdTraceRaysKHR", (void*)CmdTraceRaysKHR}, + {"vkCreateRayTracingPipelinesKHR", (void*)CreateRayTracingPipelinesKHR}, + {"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", (void*)GetRayTracingCaptureReplayShaderGroupHandlesKHR}, + {"vkCmdTraceRaysIndirectKHR", (void*)CmdTraceRaysIndirectKHR}, + {"vkGetRayTracingShaderGroupStackSizeKHR", (void*)GetRayTracingShaderGroupStackSizeKHR}, + {"vkCmdSetRayTracingPipelineStackSizeKHR", (void*)CmdSetRayTracingPipelineStackSizeKHR}, + {"vkCmdDrawMeshTasksEXT", (void*)CmdDrawMeshTasksEXT}, + {"vkCmdDrawMeshTasksIndirectEXT", (void*)CmdDrawMeshTasksIndirectEXT}, + {"vkCmdDrawMeshTasksIndirectCountEXT", (void*)CmdDrawMeshTasksIndirectCountEXT}, +}; + +} // namespace vkmock + diff --git a/test/icd/generated/function_definitions.h b/test/icd/generated/function_definitions.h new file mode 100644 index 0000000000..97062bc58c --- /dev/null +++ b/test/icd/generated/function_definitions.h @@ -0,0 +1,8018 @@ +/* +** Copyright (c) 2015-2024 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 + +#include "mock_icd.h" +#include "function_declarations.h" +#include "mock_icd_test_config.h" + +namespace vkmock { + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance) +{ + + // 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; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator) +{ + + 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); + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices) +{ + 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; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures) +{ + uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); + VkBool32 *bool_array = &pFeatures->robustBufferAccess; + SetBoolArrayTrue(bool_array, num_bools); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties) +{ + 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; + } + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties) +{ + // 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; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties) +{ + if (test_config.device_api_version_override == 0) { + pProperties->apiVersion = VK_HEADER_VERSION_COMPLETE; + } else { + pProperties->apiVersion = test_config.device_api_version_override; + } + 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 }; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties) +{ + if (pQueueFamilyProperties) { + std::vector 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); + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + 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; +} + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( + VkInstance instance, + const char* pName) +{ + + 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(item->second); + } + // Mock should intercept all functions so if we get here just return null + return nullptr; +} + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( + VkDevice device, + const char* pName) +{ + + return GetInstanceProcAddr(nullptr, pName); +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice) +{ + + *pDevice = (VkDevice)CreateDispObjHandle(); + // TODO: If emulating specific device caps, will need to add intelligence here + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator) +{ + + 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 +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) +{ + + // 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; +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) +{ + + // 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; + } + if (i != device_extension_map.size()) { + return VK_INCOMPLETE; + } + } + } + // If requesting extension properties, fill in data struct for number of extensions + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties) +{ + + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties) +{ + + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue) +{ + 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; +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence) +{ + // 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(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; +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( + VkQueue queue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( + VkDevice device) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory) +{ + unique_lock_t lock(global_lock); + allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize; + *pMemory = (VkDeviceMemory)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL FreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object + UnmapMemory(device, memory); + unique_lock_t lock(global_lock); + allocated_memory_size_map.erase(memory); +} + +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData) +{ + 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; +} + +static VKAPI_ATTR void VKAPI_CALL UnmapMemory( + VkDevice device, + VkDeviceMemory memory) +{ + unique_lock_t lock(global_lock); + for (auto map_addr : mapped_memory_map[memory]) { + free(map_addr); + } + mapped_memory_map.erase(memory); +} + +static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements) +{ + // 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; + } + } +} + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements) +{ + 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); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + 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; + } + +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties) +{ + 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; + } + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence) +{ + unique_lock_t lock(global_lock); + *pFence = (VkFence)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( + VkDevice device, + VkFence fence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore) +{ + unique_lock_t lock(global_lock); + *pSemaphore = (VkSemaphore)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent) +{ + unique_lock_t lock(global_lock); + *pEvent = (VkEvent)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( + VkDevice device, + VkEvent event) +{ +//Not a CREATE or DESTROY function + return VK_EVENT_SET; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetEvent( + VkDevice device, + VkEvent event) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( + VkDevice device, + VkEvent event) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool) +{ + unique_lock_t lock(global_lock); + *pQueryPool = (VkQueryPool)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer) +{ + 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; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator) +{ + unique_lock_t lock(global_lock); + buffer_map[device].erase(buffer); +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView) +{ + unique_lock_t lock(global_lock); + *pView = (VkBufferView)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage) +{ + unique_lock_t lock(global_lock); + *pImage = (VkImage)global_unique_handle++; + image_memory_size_map[device][*pImage] = GetImageSizeFromCreateInfo(pCreateInfo); + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator) +{ + unique_lock_t lock(global_lock); + image_memory_size_map[device].erase(image); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout) +{ + // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. + *pLayout = VkSubresourceLayout(); // Default constructor zero values. +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView) +{ + unique_lock_t lock(global_lock); + *pView = (VkImageView)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule) +{ + unique_lock_t lock(global_lock); + *pShaderModule = (VkShaderModule)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache) +{ + unique_lock_t lock(global_lock); + *pPipelineCache = (VkPipelineCache)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout) +{ + unique_lock_t lock(global_lock); + *pPipelineLayout = (VkPipelineLayout)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler) +{ + unique_lock_t lock(global_lock); + *pSampler = (VkSampler)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout) +{ + unique_lock_t lock(global_lock); + *pSetLayout = (VkDescriptorSetLayout)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool) +{ + unique_lock_t lock(global_lock); + *pDescriptorPool = (VkDescriptorPool)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) { + pDescriptorSets[i] = (VkDescriptorSet)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets) +{ +//Destroy object + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer) +{ + unique_lock_t lock(global_lock); + *pFramebuffer = (VkFramebuffer)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass) +{ + unique_lock_t lock(global_lock); + *pRenderPass = (VkRenderPass)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity) +{ + pGranularity->width = 1; + pGranularity->height = 1; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool) +{ + unique_lock_t lock(global_lock); + *pCommandPool = (VkCommandPool)global_unique_handle++; + command_pool_map[device].insert(*pCommandPool); + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator) +{ + + // 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); +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) +{ + + 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; +} + +static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) +{ + + 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]); + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion( + uint32_t* pApiVersion) +{ + + *pApiVersion = VK_HEADER_VERSION_COMPLETE; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + return EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures) +{ + GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties) +{ + GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties) +{ + GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties) +{ + return GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties) +{ + GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); +} + +static VKAPI_ATTR void VKAPI_CALL TrimCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( + VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue) +{ + GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue); + // TODO: Add further support for GetDeviceQueue2 features +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion) +{ + unique_lock_t lock(global_lock); + *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + unique_lock_t lock(global_lock); + *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties) +{ + 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; + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties) +{ + // Hard-code support for all handle types and features + pExternalFenceProperties->exportFromImportedHandleTypes = 0xF; + pExternalFenceProperties->compatibleHandleTypes = 0xF; + pExternalFenceProperties->externalFenceFeatures = 0x3; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + // Hard code support for all handle types and features + pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F; + pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F; + pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3; +} + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport) +{ + if (pSupport) { + pSupport->supported = VK_TRUE; + } +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass) +{ + unique_lock_t lock(global_lock); + *pRenderPass = (VkRenderPass)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL ResetQueryPool( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ + 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; +} + +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot) +{ + unique_lock_t lock(global_lock); + *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + // 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; +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + 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); +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported) +{ + // Currently say that all surface/queue combos are supported + *pSupported = VK_TRUE; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) +{ + // 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; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats) +{ + // 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; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) +{ + // 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; + } + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain) +{ + 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; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator) +{ + unique_lock_t lock(global_lock); + swapchain_image_map.clear(); +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages) +{ + 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; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex) +{ + *pImageIndex = 0; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( + VkDevice device, + const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex) +{ + *pImageIndex = 0; + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties) +{ + 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; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode) +{ + unique_lock_t lock(global_lock); + *pMode = (VkDisplayModeKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < swapchainCount; ++i) { + pSwapchains[i] = (VkSwapchainKHR)global_unique_handle++; + } + return VK_SUCCESS; +} + +#ifdef VK_USE_PLATFORM_XLIB_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_XLIB_KHR */ + +#ifdef VK_USE_PLATFORM_XCB_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR( + VkInstance instance, + const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_XCB_KHR */ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR( + VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR( + VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR( + VkInstance instance, + const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities) +{ + // We include some reasonable set of capability combinations to cover a wide range of use cases + auto caps = pCapabilities; + auto caps_decode = lvl_find_mod_in_chain(pCapabilities->pNext); + auto caps_decode_h264 = lvl_find_mod_in_chain(pCapabilities->pNext); + auto caps_decode_h265 = lvl_find_mod_in_chain(pCapabilities->pNext); + auto caps_decode_av1 = lvl_find_mod_in_chain(pCapabilities->pNext); + auto caps_encode = lvl_find_mod_in_chain(pCapabilities->pNext); + auto caps_encode_h264 = lvl_find_mod_in_chain(pCapabilities->pNext); + auto caps_encode_h265 = lvl_find_mod_in_chain(pCapabilities->pNext); + + switch (pVideoProfile->videoCodecOperation) { + case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: { + auto profile = lvl_find_in_chain(pVideoProfile->pNext); + if (profile->stdProfileIdc != STD_VIDEO_H264_PROFILE_IDC_BASELINE && + profile->stdProfileIdc != STD_VIDEO_H264_PROFILE_IDC_MAIN) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + + caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; + caps->minBitstreamBufferOffsetAlignment = 256; + caps->minBitstreamBufferSizeAlignment = 256; + caps->pictureAccessGranularity = {16,16}; + caps->minCodedExtent = {16,16}; + caps->maxCodedExtent = {1920,1080}; + caps->maxDpbSlots = 33; + caps->maxActiveReferencePictures = 32; + std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME, + sizeof(caps->stdHeaderVersion.extensionName)); + caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION; + + switch (pVideoProfile->chromaSubsampling) { + case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: + if (profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR; + caps_decode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_6_2; + caps_decode_h264->fieldOffsetGranularity = {0,0}; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: + if (profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR && + profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; + caps_decode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_5_0; + caps_decode_h264->fieldOffsetGranularity = {0,16}; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: + if (profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR && + profile->pictureLayout != VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR + | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; + caps_decode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_3_2; + caps_decode_h264->fieldOffsetGranularity = {0,1}; + break; + default: + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + break; + } + case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: { + auto profile = lvl_find_in_chain(pVideoProfile->pNext); + if (profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + + caps->flags = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR; + caps->minBitstreamBufferOffsetAlignment = 64; + caps->minBitstreamBufferSizeAlignment = 64; + caps->pictureAccessGranularity = {32,32}; + caps->minCodedExtent = {48,48}; + caps->maxCodedExtent = {3840,2160}; + caps->maxDpbSlots = 16; + caps->maxActiveReferencePictures = 15; + std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME, + sizeof(caps->stdHeaderVersion.extensionName)); + caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION; + + switch (pVideoProfile->chromaSubsampling) { + case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: + caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR; + caps_decode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_0; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: + caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; + caps_decode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_5_2; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: + caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR + | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; + caps_decode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_4_1; + break; + default: + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + break; + } + case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: { + auto profile = lvl_find_in_chain(pVideoProfile->pNext); + if (profile->stdProfile != STD_VIDEO_AV1_PROFILE_MAIN) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + + caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; + caps->minBitstreamBufferOffsetAlignment = 256; + caps->minBitstreamBufferSizeAlignment = 256; + caps->pictureAccessGranularity = {16,16}; + caps->minCodedExtent = {16,16}; + caps->maxCodedExtent = {1920,1080}; + caps->maxDpbSlots = 8; + caps->maxActiveReferencePictures = 7; + std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME, + sizeof(caps->stdHeaderVersion.extensionName)); + caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION; + + switch (pVideoProfile->chromaSubsampling) { + case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: + caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR; + caps_decode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_6_2; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: + if (profile->filmGrainSupport) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; + caps_decode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_5_0; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: + caps_decode->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR + | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; + caps_decode_av1->maxLevel = STD_VIDEO_AV1_LEVEL_3_2; + break; + default: + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + break; + } + case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: { + auto profile = lvl_find_in_chain(pVideoProfile->pNext); + if (profile->stdProfileIdc != STD_VIDEO_H264_PROFILE_IDC_BASELINE) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + + caps->flags = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR; + caps->minBitstreamBufferOffsetAlignment = 4096; + caps->minBitstreamBufferSizeAlignment = 4096; + caps->pictureAccessGranularity = {16,16}; + caps->minCodedExtent = {160,128}; + caps->maxCodedExtent = {1920,1080}; + caps->maxDpbSlots = 10; + caps->maxActiveReferencePictures = 4; + std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME, + sizeof(caps->stdHeaderVersion.extensionName)); + caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION; + + switch (pVideoProfile->chromaSubsampling) { + case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: + caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR; + caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR + | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR + | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; + caps_encode->maxRateControlLayers = 4; + caps_encode->maxBitrate = 800000000; + caps_encode->maxQualityLevels = 4; + caps_encode->encodeInputPictureGranularity = {16,16}; + caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR + | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR + | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR; + caps_encode_h264->flags = VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR + | VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR + | VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR + | VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR + | VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR + | VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR; + caps_encode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_6_2; + caps_encode_h264->maxSliceCount = 8; + caps_encode_h264->maxPPictureL0ReferenceCount = 4; + caps_encode_h264->maxBPictureL0ReferenceCount = 3; + caps_encode_h264->maxL1ReferenceCount = 2; + caps_encode_h264->maxTemporalLayerCount = 4; + caps_encode_h264->expectDyadicTemporalLayerPattern = VK_FALSE; + caps_encode_h264->minQp = 0; + caps_encode_h264->maxQp = 51; + caps_encode_h264->prefersGopRemainingFrames = VK_FALSE; + caps_encode_h264->requiresGopRemainingFrames = VK_FALSE; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: + caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR; + caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR + | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; + caps_encode->maxRateControlLayers = 1; + caps_encode->maxBitrate = 480000000; + caps_encode->maxQualityLevels = 3; + caps_encode->encodeInputPictureGranularity = {32,32}; + caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR + | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; + caps_encode_h264->flags = VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR + | VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR + | VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR; + caps_encode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_6_1; + caps_encode_h264->maxSliceCount = 4; + caps_encode_h264->maxPPictureL0ReferenceCount = 4; + caps_encode_h264->maxBPictureL0ReferenceCount = 0; + caps_encode_h264->maxL1ReferenceCount = 0; + caps_encode_h264->maxTemporalLayerCount = 4; + caps_encode_h264->expectDyadicTemporalLayerPattern = VK_TRUE; + caps_encode_h264->minQp = 0; + caps_encode_h264->maxQp = 30; + caps_encode_h264->prefersGopRemainingFrames = VK_TRUE; + caps_encode_h264->requiresGopRemainingFrames = VK_FALSE; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: + caps_encode->flags = 0; + caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR; + caps_encode->maxRateControlLayers = 1; + caps_encode->maxBitrate = 240000000; + caps_encode->maxQualityLevels = 1; + caps_encode->encodeInputPictureGranularity = {1,1}; + caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR + | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; + caps_encode_h264->flags = VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR + | VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR + | VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR; + caps_encode_h264->maxLevelIdc = STD_VIDEO_H264_LEVEL_IDC_5_1; + caps_encode_h264->maxSliceCount = 1; + caps_encode_h264->maxPPictureL0ReferenceCount = 0; + caps_encode_h264->maxBPictureL0ReferenceCount = 2; + caps_encode_h264->maxL1ReferenceCount = 2; + caps_encode_h264->maxTemporalLayerCount = 1; + caps_encode_h264->expectDyadicTemporalLayerPattern = VK_FALSE; + caps_encode_h264->minQp = 5; + caps_encode_h264->maxQp = 40; + caps_encode_h264->prefersGopRemainingFrames = VK_TRUE; + caps_encode_h264->requiresGopRemainingFrames = VK_TRUE; + break; + default: + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + break; + } + case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: { + auto profile = lvl_find_in_chain(pVideoProfile->pNext); + if (profile->stdProfileIdc != STD_VIDEO_H265_PROFILE_IDC_MAIN) { + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + + caps->flags = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR; + caps->minBitstreamBufferOffsetAlignment = 1; + caps->minBitstreamBufferSizeAlignment = 1; + caps->pictureAccessGranularity = {8,8}; + caps->minCodedExtent = {64,48}; + caps->maxCodedExtent = {4096,2560}; + caps->maxDpbSlots = 8; + caps->maxActiveReferencePictures = 2; + std::strncpy(caps->stdHeaderVersion.extensionName, VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME, sizeof(caps->stdHeaderVersion.extensionName)); + caps->stdHeaderVersion.specVersion = VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION; + + switch (pVideoProfile->chromaSubsampling) { + case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: + caps_encode->flags = 0; + caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR; + caps_encode->maxRateControlLayers = 1; + caps_encode->maxBitrate = 800000000; + caps_encode->maxQualityLevels = 1; + caps_encode->encodeInputPictureGranularity = {64,64}; + caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR + | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; + caps_encode_h265->flags = VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR + | VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR + | VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR + | VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR + | VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR + | VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR; + caps_encode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_2; + caps_encode_h265->maxSliceSegmentCount = 8; + caps_encode_h265->maxTiles = {1,1}; + caps_encode_h265->ctbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR + | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; + caps_encode_h265->transformBlockSizes = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR + | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR + | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR; + caps_encode_h265->maxPPictureL0ReferenceCount = 4; + caps_encode_h265->maxBPictureL0ReferenceCount = 3; + caps_encode_h265->maxL1ReferenceCount = 2; + caps_encode_h265->maxSubLayerCount = 1; + caps_encode_h265->expectDyadicTemporalSubLayerPattern = VK_FALSE; + caps_encode_h265->minQp = 16; + caps_encode_h265->maxQp = 32; + caps_encode_h265->prefersGopRemainingFrames = VK_FALSE; + caps_encode_h265->requiresGopRemainingFrames = VK_FALSE; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: + caps_encode->flags = 0; + caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR; + caps_encode->maxRateControlLayers = 0; + caps_encode->maxBitrate = 480000000; + caps_encode->maxQualityLevels = 2; + caps_encode->encodeInputPictureGranularity = {32,32}; + caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR + | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR; + caps_encode_h265->flags = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR; + caps_encode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_6_1; + caps_encode_h265->maxSliceSegmentCount = 4; + caps_encode_h265->maxTiles = {2,2}; + caps_encode_h265->ctbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR + | VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR; + caps_encode_h265->transformBlockSizes = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR + | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR + | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR; + caps_encode_h265->maxPPictureL0ReferenceCount = 4; + caps_encode_h265->maxBPictureL0ReferenceCount = 0; + caps_encode_h265->maxL1ReferenceCount = 0; + caps_encode_h265->maxSubLayerCount = 1; + caps_encode_h265->expectDyadicTemporalSubLayerPattern = VK_FALSE; + caps_encode_h265->minQp = 0; + caps_encode_h265->maxQp = 51; + caps_encode_h265->prefersGopRemainingFrames = VK_TRUE; + caps_encode_h265->requiresGopRemainingFrames = VK_FALSE; + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: + caps_encode->flags = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR; + caps_encode->rateControlModes = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR + | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR + | VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR; + caps_encode->maxRateControlLayers = 2; + caps_encode->maxBitrate = 240000000; + caps_encode->maxQualityLevels = 3; + caps_encode->encodeInputPictureGranularity = {16,16}; + caps_encode->supportedEncodeFeedbackFlags = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR + | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR + | VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR; + caps_encode_h265->flags = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR + | VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR + | VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR; + caps_encode_h265->maxLevelIdc = STD_VIDEO_H265_LEVEL_IDC_5_1; + caps_encode_h265->maxSliceSegmentCount = 1; + caps_encode_h265->maxTiles = {2,2}; + caps_encode_h265->ctbSizes = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR; + caps_encode_h265->transformBlockSizes = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR; + caps_encode_h265->maxPPictureL0ReferenceCount = 0; + caps_encode_h265->maxBPictureL0ReferenceCount = 2; + caps_encode_h265->maxL1ReferenceCount = 2; + caps_encode_h265->maxSubLayerCount = 4; + caps_encode_h265->expectDyadicTemporalSubLayerPattern = VK_TRUE; + caps_encode_h265->minQp = 16; + caps_encode_h265->maxQp = 51; + caps_encode_h265->prefersGopRemainingFrames = VK_TRUE; + caps_encode_h265->requiresGopRemainingFrames = VK_TRUE; + break; + default: + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + break; + } + + default: + break; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR* pVideoFormatProperties) +{ + // We include some reasonable set of format combinations to cover a wide range of use cases + auto profile_list = lvl_find_in_chain(pVideoFormatInfo->pNext); + if (profile_list->profileCount != 1) { + return VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR; + } + + std::vector format_props{}; + + VkVideoFormatPropertiesKHR props = {}; + props.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; + props.imageCreateFlags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT + | VK_IMAGE_CREATE_ALIAS_BIT + | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT + | VK_IMAGE_CREATE_PROTECTED_BIT + | VK_IMAGE_CREATE_DISJOINT_BIT; + props.imageType = VK_IMAGE_TYPE_2D; + props.imageTiling = VK_IMAGE_TILING_OPTIMAL; + + switch (profile_list->pProfiles[0].videoCodecOperation) { + case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: + case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: + case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: + switch (profile_list->pProfiles[0].chromaSubsampling) { + case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: + props.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; + props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT + | VK_IMAGE_USAGE_TRANSFER_DST_BIT + | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; + format_props.push_back(props); + props.imageUsageFlags = 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_VIDEO_DECODE_DST_BIT_KHR + | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR + | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; + format_props.push_back(props); + props.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; + format_props.push_back(props); + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: + props.imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; + props.format = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM; + format_props.push_back(props); + props.imageUsageFlags = 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_VIDEO_DECODE_DST_BIT_KHR + | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; + format_props.push_back(props); + props.format = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; + format_props.push_back(props); + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: + props.format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM; + props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT + | VK_IMAGE_USAGE_TRANSFER_DST_BIT + | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; + format_props.push_back(props); + props.imageUsageFlags = 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_VIDEO_DECODE_DST_BIT_KHR + | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR + | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; + format_props.push_back(props); + break; + default: + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + break; + case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: + case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: + switch (profile_list->pProfiles[0].chromaSubsampling) { + case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: + props.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; + props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT + | VK_IMAGE_USAGE_TRANSFER_DST_BIT + | VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR; + format_props.push_back(props); + props.imageUsageFlags = 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_VIDEO_DECODE_DST_BIT_KHR + | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; + format_props.push_back(props); + props.format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; + format_props.push_back(props); + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: + props.format = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM; + props.imageUsageFlags = VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR; + format_props.push_back(props); + props.imageUsageFlags = 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_VIDEO_DECODE_DST_BIT_KHR + | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; + format_props.push_back(props); + props.format = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; + format_props.push_back(props); + break; + case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: + props.format = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM; + props.imageUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT + | VK_IMAGE_USAGE_TRANSFER_DST_BIT + | VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR; + format_props.push_back(props); + props.imageUsageFlags = 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_VIDEO_DECODE_DST_BIT_KHR + | VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR; + format_props.push_back(props); + break; + default: + return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR; + } + break; + + default: + break; + } + + std::vector filtered_props; + for (const auto& fmt_props : format_props) { + if ((pVideoFormatInfo->imageUsage & fmt_props.imageUsageFlags) == pVideoFormatInfo->imageUsage) { + filtered_props.push_back(fmt_props); + } + } + + if (pVideoFormatProperties != nullptr) { + for (uint32_t i = 0; i < (std::min)(*pVideoFormatPropertyCount, (uint32_t)filtered_props.size()); ++i) { + pVideoFormatProperties[i] = filtered_props[i]; + } + } + *pVideoFormatPropertyCount = (uint32_t)filtered_props.size(); + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR( + VkDevice device, + const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession) +{ + unique_lock_t lock(global_lock); + *pVideoSession = (VkVideoSessionKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) +{ + 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; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR( + VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters) +{ + unique_lock_t lock(global_lock); + *pVideoSessionParameters = (VkVideoSessionParametersKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoDecodeInfoKHR* pDecodeInfo) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures) +{ + 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(pFeatures->pNext); + if (vk_1_1_features) { + vk_1_1_features->protectedMemory = VK_TRUE; + } + auto vk_1_3_features = lvl_find_mod_in_chain(pFeatures->pNext); + if (vk_1_3_features) { + vk_1_3_features->synchronization2 = VK_TRUE; + } + auto prot_features = lvl_find_mod_in_chain(pFeatures->pNext); + if (prot_features) { + prot_features->protectedMemory = VK_TRUE; + } + auto sync2_features = lvl_find_mod_in_chain(pFeatures->pNext); + if (sync2_features) { + sync2_features->synchronization2 = VK_TRUE; + } + auto video_maintenance1_features = lvl_find_mod_in_chain(pFeatures->pNext); + if (video_maintenance1_features) { + video_maintenance1_features->videoMaintenance1 = VK_TRUE; + } + const auto *desc_idx_features = lvl_find_in_chain(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(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(pFeatures->pNext); + if (host_image_copy_features) { + feat_bools = (VkBool32*)&host_image_copy_features->hostImageCopy; + SetBoolArrayTrue(feat_bools, 1); + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties) +{ + // 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(pProperties->pNext); + if (props_11) { + props_11->protectedNoFault = VK_FALSE; + } + + auto *props_12 = lvl_find_mod_in_chain(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(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(pProperties->pNext); + if (protected_memory_props) { + protected_memory_props->protectedNoFault = VK_FALSE; + } + + auto *float_controls_props = lvl_find_mod_in_chain(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(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(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(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(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(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(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(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; + } + + 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(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(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 + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties) +{ + GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties); + VkFormatProperties3KHR *props_3 = lvl_find_mod_in_chain(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; + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties) +{ + auto *external_image_prop = lvl_find_mod_in_chain(pImageFormatProperties->pNext); + auto *external_image_format = lvl_find_in_chain(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; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + 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(pQueueFamilyProperties[1].pNext); + if (status_query_props) { + status_query_props->queryResultStatusSupport = VK_TRUE; + } + auto video_props = lvl_find_mod_in_chain(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(pQueueFamilyProperties[2].pNext); + if (status_query_props) { + status_query_props->queryResultStatusSupport = VK_TRUE; + } + auto video_props = lvl_find_mod_in_chain(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; + } + } + if (*pQueueFamilyPropertyCount > 3) { + *pQueueFamilyPropertyCount = 3; + } + } else { + *pQueueFamilyPropertyCount = 3; + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties) +{ + 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); + } +} + + +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( + VkCommandBuffer commandBuffer, + uint32_t deviceMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + 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; +} + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties) +{ + GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); +} + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) +{ + pMemoryWin32HandleProperties->memoryTypeBits = 0xFFFF; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd) +{ + *pFd = 1; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +} + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + unique_lock_t lock(global_lock); + *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass) +{ + unique_lock_t lock(global_lock); + *pRenderPass = (VkRenderPass)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties) +{ + GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); +} + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) +{ + *pHandle = (HANDLE)0x12345678; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd) +{ + *pFd = 0x42; + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions) +{ + 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; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses) +{ + if (pNumPasses) { + // arbitrary + *pNumPasses = 1; + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR( + VkDevice device, + const VkAcquireProfilingLockInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR( + VkDevice device) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities) +{ + GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities); + + auto *present_mode_compatibility = lvl_find_mod_in_chain(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; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats) +{ + // 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; +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + if (pSparseMemoryRequirementCount && pSparseMemoryRequirements) { + GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, &pSparseMemoryRequirements->memoryRequirements); + } else { + GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, nullptr); + } +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion) +{ + unique_lock_t lock(global_lock); + *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport) +{ + GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + + + + + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) +{ + 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; +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR( + VkCommandBuffer commandBuffer, + const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingAttachmentLocationsKHR( + VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfoKHR* pLocationInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRenderingInputAttachmentIndicesKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInputAttachmentIndexInfoKHR* pInputAttachmentIndexInfo) +{ +//Not a CREATE or DESTROY function +} + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t presentId, + uint64_t timeout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ + return GetBufferDeviceAddress(device, pInfo); +} + +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR( + VkDevice device, + const VkAllocationCallbacks* pAllocator, + VkDeferredOperationKHR* pDeferredOperation) +{ + unique_lock_t lock(global_lock); + *pDeferredOperation = (VkDeferredOperationKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR( + VkDevice device, + VkDeferredOperationKHR operation, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR( + VkDevice device, + VkDeferredOperationKHR operation) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR( + VkDevice device, + VkDeferredOperationKHR operation) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR( + VkDevice device, + VkDeferredOperationKHR operation) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( + VkDevice device, + const VkPipelineInfoKHR* pPipelineInfo, + uint32_t* pExecutableCount, + VkPipelineExecutablePropertiesKHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pStatisticCount, + VkPipelineExecutableStatisticKHR* pStatistics) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pInternalRepresentationCount, + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR( + VkDevice device, + const VkMemoryMapInfoKHR* pMemoryMapInfo, + void** ppData) +{ + return MapMemory(device, pMemoryMapInfo->memory, pMemoryMapInfo->offset, pMemoryMapInfo->size, pMemoryMapInfo->flags, ppData); +} + +static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR( + VkDevice device, + const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) +{ + UnmapMemory(device, pMemoryUnmapInfo->memory); + return VK_SUCCESS; +} + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetEncodedVideoSessionParametersKHR( + VkDevice device, + const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, + size_t* pDataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoEncodeInfoKHR* pEncodeInfo) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData) +{ +//Not a CREATE or DESTROY function +} + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectDeviceAddress) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR( + VkDevice device, + const VkRenderingAreaInfoKHR* pRenderingAreaInfo, + VkExtent2D* pGranularity) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR( + VkDevice device, + const VkDeviceImageSubresourceInfoKHR* pInfo, + VkSubresourceLayout2KHR* pLayout) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR( + VkDevice device, + VkImage image, + const VkImageSubresource2KHR* pSubresource, + VkSubresourceLayout2KHR* pLayout) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineBinariesKHR( + VkDevice device, + const VkPipelineBinaryCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineBinaryHandlesInfoKHR* pBinaries) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < pBinaries->pipelineBinaryCount; ++i) { + pBinaries->pPipelineBinaries[i] = (VkPipelineBinaryKHR)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineBinaryKHR( + VkDevice device, + VkPipelineBinaryKHR pipelineBinary, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineKeyKHR( + VkDevice device, + const VkPipelineCreateInfoKHR* pPipelineCreateInfo, + VkPipelineBinaryKeyKHR* pPipelineKey) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineBinaryDataKHR( + VkDevice device, + const VkPipelineBinaryDataInfoKHR* pInfo, + VkPipelineBinaryKeyKHR* pPipelineBinaryKey, + size_t* pPipelineBinaryDataSize, + void* pPipelineBinaryData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseCapturedPipelineDataKHR( + VkDevice device, + const VkReleaseCapturedPipelineDataInfoKHR* pInfo, + const VkAllocationCallbacks* pAllocator) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesKHR* pProperties) +{ + 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; +} + + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleKHR( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains) +{ + if (!pTimeDomains) { + *pTimeDomainCount = 1; + } else { + // arbitrary + *pTimeDomains = VK_TIME_DOMAIN_DEVICE_KHR; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR( + VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR( + VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback) +{ + unique_lock_t lock(global_lock); + *pCallback = (VkDebugReportCallbackEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage) +{ +//Not a CREATE or DESTROY function +} + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( + VkDevice device, + const VkDebugMarkerObjectTagInfoEXT* pTagInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( + VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags, + uint32_t index) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + uint32_t index) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT( + VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX( + VkDevice device, + const VkCuModuleCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuModuleNVX* pModule) +{ + unique_lock_t lock(global_lock); + *pModule = (VkCuModuleNVX)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX( + VkDevice device, + const VkCuFunctionCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuFunctionNVX* pFunction) +{ + unique_lock_t lock(global_lock); + *pFunction = (VkCuFunctionNVX)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX( + VkDevice device, + VkCuModuleNVX module, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX( + VkDevice device, + VkCuFunctionNVX function, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX( + VkCommandBuffer commandBuffer, + const VkCuLaunchInfoNVX* pLaunchInfo) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX( + VkDevice device, + const VkImageViewHandleInfoNVX* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX( + VkDevice device, + VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD( + VkDevice device, + VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t* pInfoSize, + void* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +#ifdef VK_USE_PLATFORM_GGP + +static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP( + VkInstance instance, + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_GGP */ + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +#ifdef VK_USE_PLATFORM_VI_NN + +static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN( + VkInstance instance, + const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_VI_NN */ + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + VkDisplayKHR display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence) +{ + unique_lock_t lock(global_lock); + *pFence = (VkFence)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 discardRectangleEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT( + VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata) +{ +//Not a CREATE or DESTROY function +} + + +#ifdef VK_USE_PLATFORM_IOS_MVK + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_IOS_MVK */ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK( + VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_MACOS_MVK */ + + + + +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( + VkDevice device, + const VkDebugUtilsObjectNameInfoEXT* pNameInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( + VkDevice device, + const VkDebugUtilsObjectTagInfoEXT* pTagInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( + VkQueue queue) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger) +{ + unique_lock_t lock(global_lock); + *pMessenger = (VkDebugUtilsMessengerEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( + VkDevice device, + const struct AHardwareBuffer* buffer, + VkAndroidHardwareBufferPropertiesANDROID* pProperties) +{ + pProperties->allocationSize = 65536; + pProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type + + auto *format_prop = lvl_find_mod_in_chain(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(pProperties->pNext); + if (format_resolve_prop) { + format_resolve_prop->colorAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( + VkDevice device, + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, + struct AHardwareBuffer** pBuffer) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + + + +#ifdef VK_ENABLE_BETA_EXTENSIONS + +static VKAPI_ATTR VkResult VKAPI_CALL CreateExecutionGraphPipelinesAMDX( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineScratchSizeAMDX( + VkDevice device, + VkPipeline executionGraph, + VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetExecutionGraphPipelineNodeIndexAMDX( + VkDevice device, + VkPipeline executionGraph, + const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, + uint32_t* pNodeIndex) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdInitializeGraphScratchMemoryAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + const VkDispatchGraphCountInfoAMDX* pCountInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + const VkDispatchGraphCountInfoAMDX* pCountInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchGraphIndirectCountAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + VkDeviceAddress countInfo) +{ +//Not a CREATE or DESTROY function +} +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties) +{ + if (pMultisampleProperties) { + // arbitrary + pMultisampleProperties->maxSampleLocationGridSize = {32, 32}; + } +} + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT( + VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( + VkDevice device, + const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache) +{ + unique_lock_t lock(global_lock); + *pValidationCache = (VkValidationCacheEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( + VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + size_t* pDataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV( + VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV( + VkDevice device, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure) +{ + unique_lock_t lock(global_lock); + *pAccelerationStructure = (VkAccelerationStructureNV)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV( + VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) +{ + // arbitrary + pMemoryRequirements->memoryRequirements.size = 4096; + pMemoryRequirements->memoryRequirements.alignment = 1; + pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV( + VkDevice device, + uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV( + VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV* pInfo, + VkBuffer instanceData, + VkDeviceSize instanceOffset, + VkBool32 update, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkBuffer scratch, + VkDeviceSize scratchOffset) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV( + VkCommandBuffer commandBuffer, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeKHR mode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV( + VkCommandBuffer commandBuffer, + VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, + VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, + VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, + VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, + VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, + VkDeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV( + VkDevice device, + VkPipeline pipeline, + uint32_t shader) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) +{ + pMemoryHostPointerProperties->memoryTypeBits = 1 << 5; // DEVICE_LOCAL only type + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains) +{ + if (!pTimeDomains) { + *pTimeDomainCount = 1; + } else { + // arbitrary + *pTimeDomains = VK_TIME_DOMAIN_DEVICE_EXT; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +#ifdef VK_USE_PLATFORM_GGP +#endif /* VK_USE_PLATFORM_GGP */ + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV( + VkCommandBuffer commandBuffer, + uint32_t taskCount, + uint32_t firstTask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D* pExclusiveScissors) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV( + VkCommandBuffer commandBuffer, + const void* pCheckpointMarker) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL( + VkDevice device, + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL( + VkDevice device) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceMarkerInfoINTEL* pMarkerInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceOverrideInfoINTEL* pOverrideInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL( + VkDevice device, + const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, + VkPerformanceConfigurationINTEL* pConfiguration) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL( + VkDevice device, + VkPerformanceConfigurationINTEL configuration) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL( + VkQueue queue, + VkPerformanceConfigurationINTEL configuration) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL( + VkDevice device, + VkPerformanceParameterTypeINTEL parameter, + VkPerformanceValueINTEL* pValue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD( + VkDevice device, + VkSwapchainKHR swapChain, + VkBool32 localDimmingEnable) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( + VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_METAL_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT( + VkInstance instance, + const VkMetalSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_METAL_EXT */ + + + + + + + + + + + + + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ + return GetBufferDeviceAddress(device, pInfo); +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + VkPhysicalDevice physicalDevice, + uint32_t* pCombinationCount, + VkFramebufferMixedSamplesCombinationNV* pCombinations) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT( + VkDevice device, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR* pModes) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT( + VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImageEXT( + VkDevice device, + const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemoryEXT( + VkDevice device, + const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImageEXT( + VkDevice device, + const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT( + VkDevice device, + uint32_t transitionCount, + const VkHostImageLayoutTransitionInfoEXT* pTransitions) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( + VkDevice device, + VkImage image, + const VkImageSubresource2KHR* pSubresource, + VkSubresourceLayout2KHR* pLayout) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT( + VkDevice device, + const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, + uint32_t groupIndex) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) +{ + unique_lock_t lock(global_lock); + *pIndirectCommandsLayout = (VkIndirectCommandsLayoutNV)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV( + VkDevice device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT( + VkCommandBuffer commandBuffer, + const VkDepthBiasInfoEXT* pDepthBiasInfo) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + VkDisplayKHR display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + uint32_t connectorId, + VkDisplayKHR* display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot) +{ + unique_lock_t lock(global_lock); + *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaModuleNV( + VkDevice device, + const VkCudaModuleCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCudaModuleNV* pModule) +{ + unique_lock_t lock(global_lock); + *pModule = (VkCudaModuleNV)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetCudaModuleCacheNV( + VkDevice device, + VkCudaModuleNV module, + size_t* pCacheSize, + void* pCacheData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCudaFunctionNV( + VkDevice device, + const VkCudaFunctionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCudaFunctionNV* pFunction) +{ + unique_lock_t lock(global_lock); + *pFunction = (VkCudaFunctionNV)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyCudaModuleNV( + VkDevice device, + VkCudaModuleNV module, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL DestroyCudaFunctionNV( + VkDevice device, + VkCudaFunctionNV function, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdCudaLaunchKernelNV( + VkCommandBuffer commandBuffer, + const VkCudaLaunchInfoNV* pLaunchInfo) +{ +//Not a CREATE or DESTROY function +} + + +#ifdef VK_USE_PLATFORM_METAL_EXT + +static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT( + VkDevice device, + VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) +{ +//Not a CREATE or DESTROY function +} +#endif /* VK_USE_PLATFORM_METAL_EXT */ + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT( + VkDevice device, + VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes) +{ + // Need to give something non-zero + *pLayoutSizeInBytes = 4; +} + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT( + VkDevice device, + VkDescriptorSetLayout layout, + uint32_t binding, + VkDeviceSize* pOffset) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT( + VkDevice device, + const VkDescriptorGetInfoEXT* pDescriptorInfo, + size_t dataSize, + void* pDescriptor) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsetsEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t* pBufferIndices, + const VkDeviceSize* pOffsets) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV( + VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ +//Not a CREATE or DESTROY function +} + + + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT( + VkInstance instance, + const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + IDirectFB* dfb) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_DIRECTFB_EXT */ + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT( + VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) +{ +//Not a CREATE or DESTROY function +} + + + + + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( + VkDevice device, + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA( + VkDevice device, + const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferCollectionFUCHSIA* pCollection) +{ + unique_lock_t lock(global_lock); + *pCollection = (VkBufferCollectionFUCHSIA)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_FUCHSIA */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + VkDevice device, + VkRenderPass renderpass, + VkExtent2D* pMaxWorkgroupSize) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV( + VkDevice device, + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV* pAddress) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT( + VkDevice device, + const VkPipelineInfoEXT* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT( + VkCommandBuffer commandBuffer, + uint32_t patchControlPoints) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT( + VkCommandBuffer commandBuffer, + VkLogicOp logicOp) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX( + VkInstance instance, + const VkScreenSurfaceCreateInfoQNX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window* window) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_SCREEN_QNX */ + + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkBool32* pColorWriteEnables) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawInfoEXT* pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT* pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t* pVertexOffset) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( + VkDevice device, + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap) +{ + unique_lock_t lock(global_lock); + *pMicromap = (VkMicromapEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( + VkDevice device, + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT( + VkDevice device, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( + VkDevice device, + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterHUAWEI( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( + VkDevice device, + VkDeviceMemory memory, + float priority) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE( + VkDevice device, + const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( + VkDevice device, + VkDescriptorSet descriptorSet, + void** ppData) +{ +//Not a CREATE or DESTROY function +} + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV( + VkCommandBuffer commandBuffer, + uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL GetPipelineIndirectMemoryRequirementsNV( + VkDevice device, + const VkComputePipelineCreateInfo* pCreateInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdUpdatePipelineIndirectBufferNV( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetPipelineIndirectDeviceAddressNV( + VkDevice device, + const VkPipelineIndirectDeviceAddressInfoNV* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClampEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( + VkCommandBuffer commandBuffer, + VkPolygonMode polygonMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( + VkDevice device, + VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier) +{ + if (pIdentifier) { + // arbitrary + pIdentifier->identifierSize = 1; + pIdentifier->identifier[0] = 0x01; + } +} + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession) +{ + unique_lock_t lock(global_lock); + *pSession = (VkOpticalFlowSessionNV)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo) +{ +//Not a CREATE or DESTROY function +} + + + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + + +static VKAPI_ATTR void VKAPI_CALL AntiLagUpdateAMD( + VkDevice device, + const VkAntiLagDataAMD* pData) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT( + VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkShaderEXT* pShaders) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pShaders[i] = (VkShaderEXT)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT( + VkDevice device, + VkShaderEXT shader, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT( + VkDevice device, + VkShaderEXT shader, + size_t* pDataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT( + VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits* pStages, + const VkShaderEXT* pShaders) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT( + VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( + VkDevice device, + VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV( + VkDevice device, + VkSwapchainKHR swapchain, + const VkLatencySleepModeInfoNV* pSleepModeInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL LatencySleepNV( + VkDevice device, + VkSwapchainKHR swapchain, + const VkLatencySleepInfoNV* pSleepInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV( + VkDevice device, + VkSwapchainKHR swapchain, + const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV( + VkDevice device, + VkSwapchainKHR swapchain, + VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV( + VkQueue queue, + const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) +{ +//Not a CREATE or DESTROY function +} + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT( + VkCommandBuffer commandBuffer, + VkImageAspectFlags aspectMask) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX( + VkDevice device, + const struct _screen_buffer* buffer, + VkScreenBufferPropertiesQNX* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_SCREEN_QNX */ + + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) +{ + unique_lock_t lock(global_lock); + *pIndirectCommandsLayout = (VkIndirectCommandsLayoutEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT( + VkDevice device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT( + VkDevice device, + const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectExecutionSetEXT* pIndirectExecutionSet) +{ + unique_lock_t lock(global_lock); + *pIndirectExecutionSet = (VkIndirectExecutionSetEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure) +{ + unique_lock_t lock(global_lock); + *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR( + VkDevice device, + VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkDeviceAddress* pIndirectDeviceAddresses, + const uint32_t* pIndirectStrides, + const uint32_t* const* ppMaxPrimitiveCounts) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR( + VkDevice device, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR( + VkDevice device, + const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) +{ + // arbitrary - need to be aligned to 256 bytes + return 0x262144; +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR( + VkDevice device, + const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) +{ + // arbitrary + pSizeInfo->accelerationStructureSize = 4; + pSizeInfo->updateScratchSize = 4; + pSizeInfo->buildScratchSize = 4; +} + + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t group, + VkShaderGroupShaderKHR groupShader) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR( + VkCommandBuffer commandBuffer, + uint32_t pipelineStackSize) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +} // namespace vkmock + diff --git a/test/icd/generated/vk_typemap_helper.h b/test/icd/generated/vk_typemap_helper.h new file mode 100644 index 0000000000..8c82b52cb6 --- /dev/null +++ b/test/icd/generated/vk_typemap_helper.h @@ -0,0 +1,8678 @@ +// *** THIS FILE IS GENERATED - DO NOT EDIT *** +// See vulkan_tools_helper_file_generator.py for modifications + + +/*************************************************************************** + * + * 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 + * Author: Courtney Goeltzenleuchter + * Author: Tobin Ehlis + * Author: Chris Forbes + * Author: John Zulauf + * + ****************************************************************************/ + +#pragma once +#include + +// 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 struct LvlSTypeMap {}; +template struct LvlTypeMap {}; + +// Map type VkBufferMemoryBarrier to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferMemoryBarrier Type; +}; + +// Map type VkImageMemoryBarrier to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; +}; + +template <> struct LvlSTypeMap { + typedef VkImageMemoryBarrier Type; +}; + +// Map type VkMemoryBarrier to id VK_STRUCTURE_TYPE_MEMORY_BARRIER +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryBarrier Type; +}; + +// Map type VkApplicationInfo to id VK_STRUCTURE_TYPE_APPLICATION_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_APPLICATION_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkApplicationInfo Type; +}; + +// Map type VkInstanceCreateInfo to id VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkInstanceCreateInfo Type; +}; + +// Map type VkDeviceQueueCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceQueueCreateInfo Type; +}; + +// Map type VkDeviceCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceCreateInfo Type; +}; + +// Map type VkSubmitInfo to id VK_STRUCTURE_TYPE_SUBMIT_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBMIT_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSubmitInfo Type; +}; + +// Map type VkMappedMemoryRange to id VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; +}; + +template <> struct LvlSTypeMap { + typedef VkMappedMemoryRange Type; +}; + +// Map type VkMemoryAllocateInfo to id VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryAllocateInfo Type; +}; + +// Map type VkBindSparseInfo to id VK_STRUCTURE_TYPE_BIND_SPARSE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBindSparseInfo Type; +}; + +// Map type VkFenceCreateInfo to id VK_STRUCTURE_TYPE_FENCE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkFenceCreateInfo Type; +}; + +// Map type VkSemaphoreCreateInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSemaphoreCreateInfo Type; +}; + +// Map type VkEventCreateInfo to id VK_STRUCTURE_TYPE_EVENT_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkEventCreateInfo Type; +}; + +// Map type VkQueryPoolCreateInfo to id VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkQueryPoolCreateInfo Type; +}; + +// Map type VkBufferCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferCreateInfo Type; +}; + +// Map type VkBufferViewCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferViewCreateInfo Type; +}; + +// Map type VkImageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkImageCreateInfo Type; +}; + +// Map type VkImageViewCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkImageViewCreateInfo Type; +}; + +// Map type VkShaderModuleCreateInfo to id VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkShaderModuleCreateInfo Type; +}; + +// Map type VkPipelineCacheCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineCacheCreateInfo Type; +}; + +// Map type VkPipelineShaderStageCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineShaderStageCreateInfo Type; +}; + +// Map type VkComputePipelineCreateInfo to id VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkComputePipelineCreateInfo Type; +}; + +// Map type VkPipelineVertexInputStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineVertexInputStateCreateInfo Type; +}; + +// Map type VkPipelineInputAssemblyStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineInputAssemblyStateCreateInfo Type; +}; + +// Map type VkPipelineTessellationStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineTessellationStateCreateInfo Type; +}; + +// Map type VkPipelineViewportStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineViewportStateCreateInfo Type; +}; + +// Map type VkPipelineRasterizationStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRasterizationStateCreateInfo Type; +}; + +// Map type VkPipelineMultisampleStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineMultisampleStateCreateInfo Type; +}; + +// Map type VkPipelineDepthStencilStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineDepthStencilStateCreateInfo Type; +}; + +// Map type VkPipelineColorBlendStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineColorBlendStateCreateInfo Type; +}; + +// Map type VkPipelineDynamicStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineDynamicStateCreateInfo Type; +}; + +// Map type VkGraphicsPipelineCreateInfo to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkGraphicsPipelineCreateInfo Type; +}; + +// Map type VkPipelineLayoutCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineLayoutCreateInfo Type; +}; + +// Map type VkSamplerCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerCreateInfo Type; +}; + +// Map type VkCopyDescriptorSet to id VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyDescriptorSet Type; +}; + +// Map type VkDescriptorPoolCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorPoolCreateInfo Type; +}; + +// Map type VkDescriptorSetAllocateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorSetAllocateInfo Type; +}; + +// Map type VkDescriptorSetLayoutCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorSetLayoutCreateInfo Type; +}; + +// Map type VkWriteDescriptorSet to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; +}; + +template <> struct LvlSTypeMap { + typedef VkWriteDescriptorSet Type; +}; + +// Map type VkFramebufferCreateInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkFramebufferCreateInfo Type; +}; + +// Map type VkRenderPassCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassCreateInfo Type; +}; + +// Map type VkCommandPoolCreateInfo to id VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkCommandPoolCreateInfo Type; +}; + +// Map type VkCommandBufferAllocateInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkCommandBufferAllocateInfo Type; +}; + +// Map type VkCommandBufferInheritanceInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkCommandBufferInheritanceInfo Type; +}; + +// Map type VkCommandBufferBeginInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkCommandBufferBeginInfo Type; +}; + +// Map type VkRenderPassBeginInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassBeginInfo Type; +}; + +// Map type VkPhysicalDeviceSubgroupProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSubgroupProperties Type; +}; + +// Map type VkBindBufferMemoryInfo to id VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBindBufferMemoryInfo Type; +}; + +// Map type VkBindImageMemoryInfo to id VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBindImageMemoryInfo Type; +}; + +// Map type VkPhysicalDevice16BitStorageFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevice16BitStorageFeatures Type; +}; + +// Map type VkMemoryDedicatedRequirements to id VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryDedicatedRequirements Type; +}; + +// Map type VkMemoryDedicatedAllocateInfo to id VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryDedicatedAllocateInfo Type; +}; + +// Map type VkMemoryAllocateFlagsInfo to id VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryAllocateFlagsInfo Type; +}; + +// Map type VkDeviceGroupRenderPassBeginInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceGroupRenderPassBeginInfo Type; +}; + +// Map type VkDeviceGroupCommandBufferBeginInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceGroupCommandBufferBeginInfo Type; +}; + +// Map type VkDeviceGroupSubmitInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceGroupSubmitInfo Type; +}; + +// Map type VkDeviceGroupBindSparseInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceGroupBindSparseInfo Type; +}; + +// Map type VkBindBufferMemoryDeviceGroupInfo to id VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBindBufferMemoryDeviceGroupInfo Type; +}; + +// Map type VkBindImageMemoryDeviceGroupInfo to id VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBindImageMemoryDeviceGroupInfo Type; +}; + +// Map type VkPhysicalDeviceGroupProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceGroupProperties Type; +}; + +// Map type VkDeviceGroupDeviceCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceGroupDeviceCreateInfo Type; +}; + +// Map type VkBufferMemoryRequirementsInfo2 to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferMemoryRequirementsInfo2 Type; +}; + +// Map type VkImageMemoryRequirementsInfo2 to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkImageMemoryRequirementsInfo2 Type; +}; + +// Map type VkImageSparseMemoryRequirementsInfo2 to id VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkImageSparseMemoryRequirementsInfo2 Type; +}; + +// Map type VkMemoryRequirements2 to id VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryRequirements2 Type; +}; + +// Map type VkSparseImageMemoryRequirements2 to id VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; +}; + +template <> struct LvlSTypeMap { + typedef VkSparseImageMemoryRequirements2 Type; +}; + +// Map type VkPhysicalDeviceFeatures2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFeatures2 Type; +}; + +// Map type VkPhysicalDeviceProperties2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceProperties2 Type; +}; + +// Map type VkFormatProperties2 to id VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2; +}; + +template <> struct LvlSTypeMap { + typedef VkFormatProperties2 Type; +}; + +// Map type VkImageFormatProperties2 to id VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2; +}; + +template <> struct LvlSTypeMap { + typedef VkImageFormatProperties2 Type; +}; + +// Map type VkPhysicalDeviceImageFormatInfo2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageFormatInfo2 Type; +}; + +// Map type VkQueueFamilyProperties2 to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2; +}; + +template <> struct LvlSTypeMap { + typedef VkQueueFamilyProperties2 Type; +}; + +// Map type VkPhysicalDeviceMemoryProperties2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMemoryProperties2 Type; +}; + +// Map type VkSparseImageFormatProperties2 to id VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2; +}; + +template <> struct LvlSTypeMap { + typedef VkSparseImageFormatProperties2 Type; +}; + +// Map type VkPhysicalDeviceSparseImageFormatInfo2 to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSparseImageFormatInfo2 Type; +}; + +// Map type VkPhysicalDevicePointClippingProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePointClippingProperties Type; +}; + +// Map type VkRenderPassInputAttachmentAspectCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassInputAttachmentAspectCreateInfo Type; +}; + +// Map type VkImageViewUsageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkImageViewUsageCreateInfo Type; +}; + +// Map type VkPipelineTessellationDomainOriginStateCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineTessellationDomainOriginStateCreateInfo Type; +}; + +// Map type VkRenderPassMultiviewCreateInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassMultiviewCreateInfo Type; +}; + +// Map type VkPhysicalDeviceMultiviewFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMultiviewFeatures Type; +}; + +// Map type VkPhysicalDeviceMultiviewProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMultiviewProperties Type; +}; + +// Map type VkPhysicalDeviceVariablePointersFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVariablePointersFeatures Type; +}; + +// Map type VkPhysicalDeviceProtectedMemoryFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceProtectedMemoryFeatures Type; +}; + +// Map type VkPhysicalDeviceProtectedMemoryProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceProtectedMemoryProperties Type; +}; + +// Map type VkDeviceQueueInfo2 to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceQueueInfo2 Type; +}; + +// Map type VkProtectedSubmitInfo to id VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkProtectedSubmitInfo Type; +}; + +// Map type VkSamplerYcbcrConversionCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerYcbcrConversionCreateInfo Type; +}; + +// Map type VkSamplerYcbcrConversionInfo to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerYcbcrConversionInfo Type; +}; + +// Map type VkBindImagePlaneMemoryInfo to id VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBindImagePlaneMemoryInfo Type; +}; + +// Map type VkImagePlaneMemoryRequirementsInfo to id VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkImagePlaneMemoryRequirementsInfo Type; +}; + +// Map type VkPhysicalDeviceSamplerYcbcrConversionFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures Type; +}; + +// Map type VkSamplerYcbcrConversionImageFormatProperties to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerYcbcrConversionImageFormatProperties Type; +}; + +// Map type VkDescriptorUpdateTemplateCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorUpdateTemplateCreateInfo Type; +}; + +// Map type VkPhysicalDeviceExternalImageFormatInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExternalImageFormatInfo Type; +}; + +// Map type VkExternalImageFormatProperties to id VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalImageFormatProperties Type; +}; + +// Map type VkPhysicalDeviceExternalBufferInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExternalBufferInfo Type; +}; + +// Map type VkExternalBufferProperties to id VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalBufferProperties Type; +}; + +// Map type VkPhysicalDeviceIDProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceIDProperties Type; +}; + +// Map type VkExternalMemoryImageCreateInfo to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalMemoryImageCreateInfo Type; +}; + +// Map type VkExternalMemoryBufferCreateInfo to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalMemoryBufferCreateInfo Type; +}; + +// Map type VkExportMemoryAllocateInfo to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMemoryAllocateInfo Type; +}; + +// Map type VkPhysicalDeviceExternalFenceInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExternalFenceInfo Type; +}; + +// Map type VkExternalFenceProperties to id VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalFenceProperties Type; +}; + +// Map type VkExportFenceCreateInfo to id VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkExportFenceCreateInfo Type; +}; + +// Map type VkExportSemaphoreCreateInfo to id VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkExportSemaphoreCreateInfo Type; +}; + +// Map type VkPhysicalDeviceExternalSemaphoreInfo to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExternalSemaphoreInfo Type; +}; + +// Map type VkExternalSemaphoreProperties to id VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalSemaphoreProperties Type; +}; + +// Map type VkPhysicalDeviceMaintenance3Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMaintenance3Properties Type; +}; + +// Map type VkDescriptorSetLayoutSupport to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorSetLayoutSupport Type; +}; + +// Map type VkPhysicalDeviceShaderDrawParametersFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderDrawParametersFeatures Type; +}; + +// Map type VkPhysicalDeviceVulkan11Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVulkan11Features Type; +}; + +// Map type VkPhysicalDeviceVulkan11Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVulkan11Properties Type; +}; + +// Map type VkPhysicalDeviceVulkan12Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVulkan12Features Type; +}; + +// Map type VkPhysicalDeviceVulkan12Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVulkan12Properties Type; +}; + +// Map type VkImageFormatListCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkImageFormatListCreateInfo Type; +}; + +// Map type VkAttachmentDescription2 to id VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2; +}; + +template <> struct LvlSTypeMap { + typedef VkAttachmentDescription2 Type; +}; + +// Map type VkAttachmentReference2 to id VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2; +}; + +template <> struct LvlSTypeMap { + typedef VkAttachmentReference2 Type; +}; + +// Map type VkSubpassDescription2 to id VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2; +}; + +template <> struct LvlSTypeMap { + typedef VkSubpassDescription2 Type; +}; + +// Map type VkSubpassDependency2 to id VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; +}; + +template <> struct LvlSTypeMap { + typedef VkSubpassDependency2 Type; +}; + +// Map type VkRenderPassCreateInfo2 to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassCreateInfo2 Type; +}; + +// Map type VkSubpassBeginInfo to id VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSubpassBeginInfo Type; +}; + +// Map type VkSubpassEndInfo to id VK_STRUCTURE_TYPE_SUBPASS_END_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSubpassEndInfo Type; +}; + +// Map type VkPhysicalDevice8BitStorageFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevice8BitStorageFeatures Type; +}; + +// Map type VkPhysicalDeviceDriverProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDriverProperties Type; +}; + +// Map type VkPhysicalDeviceShaderAtomicInt64Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderAtomicInt64Features Type; +}; + +// Map type VkPhysicalDeviceShaderFloat16Int8Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderFloat16Int8Features Type; +}; + +// Map type VkPhysicalDeviceFloatControlsProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFloatControlsProperties Type; +}; + +// Map type VkDescriptorSetLayoutBindingFlagsCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorSetLayoutBindingFlagsCreateInfo Type; +}; + +// Map type VkPhysicalDeviceDescriptorIndexingFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDescriptorIndexingFeatures Type; +}; + +// Map type VkPhysicalDeviceDescriptorIndexingProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDescriptorIndexingProperties Type; +}; + +// Map type VkDescriptorSetVariableDescriptorCountAllocateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorSetVariableDescriptorCountAllocateInfo Type; +}; + +// Map type VkDescriptorSetVariableDescriptorCountLayoutSupport to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorSetVariableDescriptorCountLayoutSupport Type; +}; + +// Map type VkSubpassDescriptionDepthStencilResolve to id VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; +}; + +template <> struct LvlSTypeMap { + typedef VkSubpassDescriptionDepthStencilResolve Type; +}; + +// Map type VkPhysicalDeviceDepthStencilResolveProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDepthStencilResolveProperties Type; +}; + +// Map type VkPhysicalDeviceScalarBlockLayoutFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceScalarBlockLayoutFeatures Type; +}; + +// Map type VkImageStencilUsageCreateInfo to id VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkImageStencilUsageCreateInfo Type; +}; + +// Map type VkSamplerReductionModeCreateInfo to id VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerReductionModeCreateInfo Type; +}; + +// Map type VkPhysicalDeviceSamplerFilterMinmaxProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSamplerFilterMinmaxProperties Type; +}; + +// Map type VkPhysicalDeviceVulkanMemoryModelFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVulkanMemoryModelFeatures Type; +}; + +// Map type VkPhysicalDeviceImagelessFramebufferFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImagelessFramebufferFeatures Type; +}; + +// Map type VkFramebufferAttachmentImageInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkFramebufferAttachmentImageInfo Type; +}; + +// Map type VkFramebufferAttachmentsCreateInfo to id VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkFramebufferAttachmentsCreateInfo Type; +}; + +// Map type VkRenderPassAttachmentBeginInfo to id VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassAttachmentBeginInfo Type; +}; + +// Map type VkPhysicalDeviceUniformBufferStandardLayoutFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures Type; +}; + +// Map type VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures Type; +}; + +// Map type VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures Type; +}; + +// Map type VkAttachmentReferenceStencilLayout to id VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT; +}; + +template <> struct LvlSTypeMap { + typedef VkAttachmentReferenceStencilLayout Type; +}; + +// Map type VkAttachmentDescriptionStencilLayout to id VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; +}; + +template <> struct LvlSTypeMap { + typedef VkAttachmentDescriptionStencilLayout Type; +}; + +// Map type VkPhysicalDeviceHostQueryResetFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceHostQueryResetFeatures Type; +}; + +// Map type VkPhysicalDeviceTimelineSemaphoreFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceTimelineSemaphoreFeatures Type; +}; + +// Map type VkPhysicalDeviceTimelineSemaphoreProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceTimelineSemaphoreProperties Type; +}; + +// Map type VkSemaphoreTypeCreateInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSemaphoreTypeCreateInfo Type; +}; + +// Map type VkTimelineSemaphoreSubmitInfo to id VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkTimelineSemaphoreSubmitInfo Type; +}; + +// Map type VkSemaphoreWaitInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSemaphoreWaitInfo Type; +}; + +// Map type VkSemaphoreSignalInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSemaphoreSignalInfo Type; +}; + +// Map type VkPhysicalDeviceBufferDeviceAddressFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceBufferDeviceAddressFeatures Type; +}; + +// Map type VkBufferDeviceAddressInfo to id VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferDeviceAddressInfo Type; +}; + +// Map type VkBufferOpaqueCaptureAddressCreateInfo to id VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferOpaqueCaptureAddressCreateInfo Type; +}; + +// Map type VkMemoryOpaqueCaptureAddressAllocateInfo to id VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryOpaqueCaptureAddressAllocateInfo Type; +}; + +// Map type VkDeviceMemoryOpaqueCaptureAddressInfo to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceMemoryOpaqueCaptureAddressInfo Type; +}; + +// Map type VkPhysicalDeviceVulkan13Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVulkan13Features Type; +}; + +// Map type VkPhysicalDeviceVulkan13Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVulkan13Properties Type; +}; + +// Map type VkPipelineCreationFeedbackCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineCreationFeedbackCreateInfo Type; +}; + +// Map type VkPhysicalDeviceShaderTerminateInvocationFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderTerminateInvocationFeatures Type; +}; + +// Map type VkPhysicalDeviceToolProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceToolProperties Type; +}; + +// Map type VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures Type; +}; + +// Map type VkPhysicalDevicePrivateDataFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePrivateDataFeatures Type; +}; + +// Map type VkDevicePrivateDataCreateInfo to id VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDevicePrivateDataCreateInfo Type; +}; + +// Map type VkPrivateDataSlotCreateInfo to id VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPrivateDataSlotCreateInfo Type; +}; + +// Map type VkPhysicalDevicePipelineCreationCacheControlFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelineCreationCacheControlFeatures Type; +}; + +// Map type VkMemoryBarrier2 to id VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryBarrier2 Type; +}; + +// Map type VkBufferMemoryBarrier2 to id VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferMemoryBarrier2 Type; +}; + +// Map type VkImageMemoryBarrier2 to id VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2; +}; + +template <> struct LvlSTypeMap { + typedef VkImageMemoryBarrier2 Type; +}; + +// Map type VkDependencyInfo to id VK_STRUCTURE_TYPE_DEPENDENCY_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDependencyInfo Type; +}; + +// Map type VkSemaphoreSubmitInfo to id VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkSemaphoreSubmitInfo Type; +}; + +// Map type VkCommandBufferSubmitInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkCommandBufferSubmitInfo Type; +}; + +// Map type VkSubmitInfo2 to id VK_STRUCTURE_TYPE_SUBMIT_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkSubmitInfo2 Type; +}; + +// Map type VkPhysicalDeviceSynchronization2Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSynchronization2Features Type; +}; + +// Map type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures Type; +}; + +// Map type VkPhysicalDeviceImageRobustnessFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageRobustnessFeatures Type; +}; + +// Map type VkBufferCopy2 to id VK_STRUCTURE_TYPE_BUFFER_COPY_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COPY_2; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferCopy2 Type; +}; + +// Map type VkCopyBufferInfo2 to id VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyBufferInfo2 Type; +}; + +// Map type VkImageCopy2 to id VK_STRUCTURE_TYPE_IMAGE_COPY_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_COPY_2; +}; + +template <> struct LvlSTypeMap { + typedef VkImageCopy2 Type; +}; + +// Map type VkCopyImageInfo2 to id VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyImageInfo2 Type; +}; + +// Map type VkBufferImageCopy2 to id VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferImageCopy2 Type; +}; + +// Map type VkCopyBufferToImageInfo2 to id VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyBufferToImageInfo2 Type; +}; + +// Map type VkCopyImageToBufferInfo2 to id VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyImageToBufferInfo2 Type; +}; + +// Map type VkImageBlit2 to id VK_STRUCTURE_TYPE_IMAGE_BLIT_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2; +}; + +template <> struct LvlSTypeMap { + typedef VkImageBlit2 Type; +}; + +// Map type VkBlitImageInfo2 to id VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkBlitImageInfo2 Type; +}; + +// Map type VkImageResolve2 to id VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2; +}; + +template <> struct LvlSTypeMap { + typedef VkImageResolve2 Type; +}; + +// Map type VkResolveImageInfo2 to id VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2; +}; + +template <> struct LvlSTypeMap { + typedef VkResolveImageInfo2 Type; +}; + +// Map type VkPhysicalDeviceSubgroupSizeControlFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSubgroupSizeControlFeatures Type; +}; + +// Map type VkPhysicalDeviceSubgroupSizeControlProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSubgroupSizeControlProperties Type; +}; + +// Map type VkPipelineShaderStageRequiredSubgroupSizeCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo Type; +}; + +// Map type VkPhysicalDeviceInlineUniformBlockFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceInlineUniformBlockFeatures Type; +}; + +// Map type VkPhysicalDeviceInlineUniformBlockProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceInlineUniformBlockProperties Type; +}; + +// Map type VkWriteDescriptorSetInlineUniformBlock to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; +}; + +template <> struct LvlSTypeMap { + typedef VkWriteDescriptorSetInlineUniformBlock Type; +}; + +// Map type VkDescriptorPoolInlineUniformBlockCreateInfo to id VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorPoolInlineUniformBlockCreateInfo Type; +}; + +// Map type VkPhysicalDeviceTextureCompressionASTCHDRFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures Type; +}; + +// Map type VkRenderingAttachmentInfo to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderingAttachmentInfo Type; +}; + +// Map type VkRenderingInfo to id VK_STRUCTURE_TYPE_RENDERING_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderingInfo Type; +}; + +// Map type VkPipelineRenderingCreateInfo to id VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRenderingCreateInfo Type; +}; + +// Map type VkPhysicalDeviceDynamicRenderingFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDynamicRenderingFeatures Type; +}; + +// Map type VkCommandBufferInheritanceRenderingInfo to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; +}; + +template <> struct LvlSTypeMap { + typedef VkCommandBufferInheritanceRenderingInfo Type; +}; + +// Map type VkPhysicalDeviceShaderIntegerDotProductFeatures to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderIntegerDotProductFeatures Type; +}; + +// Map type VkPhysicalDeviceShaderIntegerDotProductProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderIntegerDotProductProperties Type; +}; + +// Map type VkPhysicalDeviceTexelBufferAlignmentProperties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceTexelBufferAlignmentProperties Type; +}; + +// Map type VkFormatProperties3 to id VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3; +}; + +template <> struct LvlSTypeMap { + typedef VkFormatProperties3 Type; +}; + +// Map type VkPhysicalDeviceMaintenance4Features to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMaintenance4Features Type; +}; + +// Map type VkPhysicalDeviceMaintenance4Properties to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMaintenance4Properties Type; +}; + +// Map type VkDeviceBufferMemoryRequirements to id VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceBufferMemoryRequirements Type; +}; + +// Map type VkDeviceImageMemoryRequirements to id VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceImageMemoryRequirements Type; +}; + +// Map type VkSwapchainCreateInfoKHR to id VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainCreateInfoKHR Type; +}; + +// Map type VkPresentInfoKHR to id VK_STRUCTURE_TYPE_PRESENT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPresentInfoKHR Type; +}; + +// Map type VkImageSwapchainCreateInfoKHR to id VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkImageSwapchainCreateInfoKHR Type; +}; + +// Map type VkBindImageMemorySwapchainInfoKHR to id VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkBindImageMemorySwapchainInfoKHR Type; +}; + +// Map type VkAcquireNextImageInfoKHR to id VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAcquireNextImageInfoKHR Type; +}; + +// Map type VkDeviceGroupPresentCapabilitiesKHR to id VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceGroupPresentCapabilitiesKHR Type; +}; + +// Map type VkDeviceGroupPresentInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceGroupPresentInfoKHR Type; +}; + +// Map type VkDeviceGroupSwapchainCreateInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceGroupSwapchainCreateInfoKHR Type; +}; + +// Map type VkDisplayModeCreateInfoKHR to id VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayModeCreateInfoKHR Type; +}; + +// Map type VkDisplaySurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplaySurfaceCreateInfoKHR Type; +}; + +// Map type VkDisplayPresentInfoKHR to id VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayPresentInfoKHR Type; +}; + +#ifdef VK_USE_PLATFORM_XLIB_KHR +// Map type VkXlibSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkXlibSurfaceCreateInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_XLIB_KHR +#ifdef VK_USE_PLATFORM_XCB_KHR +// Map type VkXcbSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkXcbSurfaceCreateInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_XCB_KHR +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +// Map type VkWaylandSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkWaylandSurfaceCreateInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WAYLAND_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkAndroidSurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAndroidSurfaceCreateInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkWin32SurfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkWin32SurfaceCreateInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +// Map type VkQueueFamilyQueryResultStatusPropertiesKHR to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkQueueFamilyQueryResultStatusPropertiesKHR Type; +}; + +// Map type VkQueueFamilyVideoPropertiesKHR to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkQueueFamilyVideoPropertiesKHR Type; +}; + +// Map type VkVideoProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoProfileInfoKHR Type; +}; + +// Map type VkVideoProfileListInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoProfileListInfoKHR Type; +}; + +// Map type VkVideoCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoCapabilitiesKHR Type; +}; + +// Map type VkPhysicalDeviceVideoFormatInfoKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVideoFormatInfoKHR Type; +}; + +// Map type VkVideoFormatPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoFormatPropertiesKHR Type; +}; + +// Map type VkVideoPictureResourceInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoPictureResourceInfoKHR Type; +}; + +// Map type VkVideoReferenceSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoReferenceSlotInfoKHR Type; +}; + +// Map type VkVideoSessionMemoryRequirementsKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoSessionMemoryRequirementsKHR Type; +}; + +// Map type VkBindVideoSessionMemoryInfoKHR to id VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkBindVideoSessionMemoryInfoKHR Type; +}; + +// Map type VkVideoSessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoSessionCreateInfoKHR Type; +}; + +// Map type VkVideoSessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoSessionParametersCreateInfoKHR Type; +}; + +// Map type VkVideoSessionParametersUpdateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoSessionParametersUpdateInfoKHR Type; +}; + +// Map type VkVideoBeginCodingInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoBeginCodingInfoKHR Type; +}; + +// Map type VkVideoEndCodingInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEndCodingInfoKHR Type; +}; + +// Map type VkVideoCodingControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoCodingControlInfoKHR Type; +}; + +// Map type VkVideoDecodeCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeCapabilitiesKHR Type; +}; + +// Map type VkVideoDecodeUsageInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeUsageInfoKHR Type; +}; + +// Map type VkVideoDecodeInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeInfoKHR Type; +}; + +// Map type VkVideoEncodeH264CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264CapabilitiesKHR Type; +}; + +// Map type VkVideoEncodeH264QualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264QualityLevelPropertiesKHR Type; +}; + +// Map type VkVideoEncodeH264SessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264SessionCreateInfoKHR Type; +}; + +// Map type VkVideoEncodeH264SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264SessionParametersAddInfoKHR Type; +}; + +// Map type VkVideoEncodeH264SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264SessionParametersCreateInfoKHR Type; +}; + +// Map type VkVideoEncodeH264SessionParametersGetInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264SessionParametersGetInfoKHR Type; +}; + +// Map type VkVideoEncodeH264SessionParametersFeedbackInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264SessionParametersFeedbackInfoKHR Type; +}; + +// Map type VkVideoEncodeH264NaluSliceInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264NaluSliceInfoKHR Type; +}; + +// Map type VkVideoEncodeH264PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264PictureInfoKHR Type; +}; + +// Map type VkVideoEncodeH264DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264DpbSlotInfoKHR Type; +}; + +// Map type VkVideoEncodeH264ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264ProfileInfoKHR Type; +}; + +// Map type VkVideoEncodeH264RateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264RateControlInfoKHR Type; +}; + +// Map type VkVideoEncodeH264RateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264RateControlLayerInfoKHR Type; +}; + +// Map type VkVideoEncodeH264GopRemainingFrameInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH264GopRemainingFrameInfoKHR Type; +}; + +// Map type VkVideoEncodeH265CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265CapabilitiesKHR Type; +}; + +// Map type VkVideoEncodeH265SessionCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265SessionCreateInfoKHR Type; +}; + +// Map type VkVideoEncodeH265QualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265QualityLevelPropertiesKHR Type; +}; + +// Map type VkVideoEncodeH265SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265SessionParametersAddInfoKHR Type; +}; + +// Map type VkVideoEncodeH265SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265SessionParametersCreateInfoKHR Type; +}; + +// Map type VkVideoEncodeH265SessionParametersGetInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265SessionParametersGetInfoKHR Type; +}; + +// Map type VkVideoEncodeH265SessionParametersFeedbackInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265SessionParametersFeedbackInfoKHR Type; +}; + +// Map type VkVideoEncodeH265NaluSliceSegmentInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265NaluSliceSegmentInfoKHR Type; +}; + +// Map type VkVideoEncodeH265PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265PictureInfoKHR Type; +}; + +// Map type VkVideoEncodeH265DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265DpbSlotInfoKHR Type; +}; + +// Map type VkVideoEncodeH265ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265ProfileInfoKHR Type; +}; + +// Map type VkVideoEncodeH265RateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265RateControlInfoKHR Type; +}; + +// Map type VkVideoEncodeH265RateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265RateControlLayerInfoKHR Type; +}; + +// Map type VkVideoEncodeH265GopRemainingFrameInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeH265GopRemainingFrameInfoKHR Type; +}; + +// Map type VkVideoDecodeH264ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH264ProfileInfoKHR Type; +}; + +// Map type VkVideoDecodeH264CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH264CapabilitiesKHR Type; +}; + +// Map type VkVideoDecodeH264SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH264SessionParametersAddInfoKHR Type; +}; + +// Map type VkVideoDecodeH264SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH264SessionParametersCreateInfoKHR Type; +}; + +// Map type VkVideoDecodeH264PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH264PictureInfoKHR Type; +}; + +// Map type VkVideoDecodeH264DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH264DpbSlotInfoKHR Type; +}; + +// Map type VkRenderingFragmentShadingRateAttachmentInfoKHR to id VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderingFragmentShadingRateAttachmentInfoKHR Type; +}; + +// Map type VkRenderingFragmentDensityMapAttachmentInfoEXT to id VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderingFragmentDensityMapAttachmentInfoEXT Type; +}; + +// Map type VkAttachmentSampleCountInfoAMD to id VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkAttachmentSampleCountInfoAMD Type; +}; + +// Map type VkMultiviewPerViewAttributesInfoNVX to id VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; +}; + +template <> struct LvlSTypeMap { + typedef VkMultiviewPerViewAttributesInfoNVX Type; +}; + +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkImportMemoryWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMemoryWin32HandleInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkExportMemoryWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMemoryWin32HandleInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkMemoryWin32HandlePropertiesKHR to id VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryWin32HandlePropertiesKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkMemoryGetWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryGetWin32HandleInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +// Map type VkImportMemoryFdInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMemoryFdInfoKHR Type; +}; + +// Map type VkMemoryFdPropertiesKHR to id VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryFdPropertiesKHR Type; +}; + +// Map type VkMemoryGetFdInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryGetFdInfoKHR Type; +}; + +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkWin32KeyedMutexAcquireReleaseInfoKHR to id VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkWin32KeyedMutexAcquireReleaseInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkImportSemaphoreWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkImportSemaphoreWin32HandleInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkExportSemaphoreWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkExportSemaphoreWin32HandleInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkD3D12FenceSubmitInfoKHR to id VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkD3D12FenceSubmitInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkSemaphoreGetWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkSemaphoreGetWin32HandleInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +// Map type VkImportSemaphoreFdInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkImportSemaphoreFdInfoKHR Type; +}; + +// Map type VkSemaphoreGetFdInfoKHR to id VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkSemaphoreGetFdInfoKHR Type; +}; + +// Map type VkPhysicalDevicePushDescriptorPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePushDescriptorPropertiesKHR Type; +}; + +// Map type VkPresentRegionsKHR to id VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPresentRegionsKHR Type; +}; + +// Map type VkSharedPresentSurfaceCapabilitiesKHR to id VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkSharedPresentSurfaceCapabilitiesKHR Type; +}; + +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkImportFenceWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkImportFenceWin32HandleInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkExportFenceWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkExportFenceWin32HandleInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkFenceGetWin32HandleInfoKHR to id VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkFenceGetWin32HandleInfoKHR Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +// Map type VkImportFenceFdInfoKHR to id VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkImportFenceFdInfoKHR Type; +}; + +// Map type VkFenceGetFdInfoKHR to id VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkFenceGetFdInfoKHR Type; +}; + +// Map type VkPhysicalDevicePerformanceQueryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePerformanceQueryFeaturesKHR Type; +}; + +// Map type VkPhysicalDevicePerformanceQueryPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePerformanceQueryPropertiesKHR Type; +}; + +// Map type VkPerformanceCounterKHR to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPerformanceCounterKHR Type; +}; + +// Map type VkPerformanceCounterDescriptionKHR to id VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPerformanceCounterDescriptionKHR Type; +}; + +// Map type VkQueryPoolPerformanceCreateInfoKHR to id VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkQueryPoolPerformanceCreateInfoKHR Type; +}; + +// Map type VkAcquireProfilingLockInfoKHR to id VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAcquireProfilingLockInfoKHR Type; +}; + +// Map type VkPerformanceQuerySubmitInfoKHR to id VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPerformanceQuerySubmitInfoKHR Type; +}; + +// Map type VkPhysicalDeviceSurfaceInfo2KHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSurfaceInfo2KHR Type; +}; + +// Map type VkSurfaceCapabilities2KHR to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceCapabilities2KHR Type; +}; + +// Map type VkSurfaceFormat2KHR to id VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceFormat2KHR Type; +}; + +// Map type VkDisplayProperties2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayProperties2KHR Type; +}; + +// Map type VkDisplayPlaneProperties2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayPlaneProperties2KHR Type; +}; + +// Map type VkDisplayModeProperties2KHR to id VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayModeProperties2KHR Type; +}; + +// Map type VkDisplayPlaneInfo2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayPlaneInfo2KHR Type; +}; + +// Map type VkDisplayPlaneCapabilities2KHR to id VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayPlaneCapabilities2KHR Type; +}; + +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDevicePortabilitySubsetFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePortabilitySubsetFeaturesKHR Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDevicePortabilitySubsetPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePortabilitySubsetPropertiesKHR Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDeviceShaderClockFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderClockFeaturesKHR Type; +}; + +// Map type VkVideoDecodeH265ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH265ProfileInfoKHR Type; +}; + +// Map type VkVideoDecodeH265CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH265CapabilitiesKHR Type; +}; + +// Map type VkVideoDecodeH265SessionParametersAddInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH265SessionParametersAddInfoKHR Type; +}; + +// Map type VkVideoDecodeH265SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH265SessionParametersCreateInfoKHR Type; +}; + +// Map type VkVideoDecodeH265PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH265PictureInfoKHR Type; +}; + +// Map type VkVideoDecodeH265DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeH265DpbSlotInfoKHR Type; +}; + +// Map type VkDeviceQueueGlobalPriorityCreateInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceQueueGlobalPriorityCreateInfoKHR Type; +}; + +// Map type VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR Type; +}; + +// Map type VkQueueFamilyGlobalPriorityPropertiesKHR to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkQueueFamilyGlobalPriorityPropertiesKHR Type; +}; + +// Map type VkFragmentShadingRateAttachmentInfoKHR to id VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkFragmentShadingRateAttachmentInfoKHR Type; +}; + +// Map type VkPipelineFragmentShadingRateStateCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineFragmentShadingRateStateCreateInfoKHR Type; +}; + +// Map type VkPhysicalDeviceFragmentShadingRateFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentShadingRateFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceFragmentShadingRatePropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentShadingRatePropertiesKHR Type; +}; + +// Map type VkPhysicalDeviceFragmentShadingRateKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentShadingRateKHR Type; +}; + +// Map type VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR Type; +}; + +// Map type VkRenderingAttachmentLocationInfoKHR to id VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderingAttachmentLocationInfoKHR Type; +}; + +// Map type VkRenderingInputAttachmentIndexInfoKHR to id VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderingInputAttachmentIndexInfoKHR Type; +}; + +// Map type VkPhysicalDeviceShaderQuadControlFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderQuadControlFeaturesKHR Type; +}; + +// Map type VkSurfaceProtectedCapabilitiesKHR to id VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceProtectedCapabilitiesKHR Type; +}; + +// Map type VkPhysicalDevicePresentWaitFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePresentWaitFeaturesKHR Type; +}; + +// Map type VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR Type; +}; + +// Map type VkPipelineInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineInfoKHR Type; +}; + +// Map type VkPipelineExecutablePropertiesKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineExecutablePropertiesKHR Type; +}; + +// Map type VkPipelineExecutableInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineExecutableInfoKHR Type; +}; + +// Map type VkPipelineExecutableStatisticKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineExecutableStatisticKHR Type; +}; + +// Map type VkPipelineExecutableInternalRepresentationKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineExecutableInternalRepresentationKHR Type; +}; + +// Map type VkMemoryMapInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryMapInfoKHR Type; +}; + +// Map type VkMemoryUnmapInfoKHR to id VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryUnmapInfoKHR Type; +}; + +// Map type VkPipelineLibraryCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineLibraryCreateInfoKHR Type; +}; + +// Map type VkPresentIdKHR to id VK_STRUCTURE_TYPE_PRESENT_ID_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPresentIdKHR Type; +}; + +// Map type VkPhysicalDevicePresentIdFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePresentIdFeaturesKHR Type; +}; + +// Map type VkVideoEncodeInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeInfoKHR Type; +}; + +// Map type VkVideoEncodeCapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeCapabilitiesKHR Type; +}; + +// Map type VkQueryPoolVideoEncodeFeedbackCreateInfoKHR to id VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkQueryPoolVideoEncodeFeedbackCreateInfoKHR Type; +}; + +// Map type VkVideoEncodeUsageInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeUsageInfoKHR Type; +}; + +// Map type VkVideoEncodeRateControlLayerInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeRateControlLayerInfoKHR Type; +}; + +// Map type VkVideoEncodeRateControlInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeRateControlInfoKHR Type; +}; + +// Map type VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR Type; +}; + +// Map type VkVideoEncodeQualityLevelPropertiesKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeQualityLevelPropertiesKHR Type; +}; + +// Map type VkVideoEncodeQualityLevelInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeQualityLevelInfoKHR Type; +}; + +// Map type VkVideoEncodeSessionParametersGetInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeSessionParametersGetInfoKHR Type; +}; + +// Map type VkVideoEncodeSessionParametersFeedbackInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoEncodeSessionParametersFeedbackInfoKHR Type; +}; + +// Map type VkQueueFamilyCheckpointProperties2NV to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkQueueFamilyCheckpointProperties2NV Type; +}; + +// Map type VkCheckpointData2NV to id VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkCheckpointData2NV Type; +}; + +// Map type VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR Type; +}; + +// Map type VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance5FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMaintenance5FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance5PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMaintenance5PropertiesKHR Type; +}; + +// Map type VkRenderingAreaInfoKHR to id VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderingAreaInfoKHR Type; +}; + +// Map type VkImageSubresource2KHR to id VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkImageSubresource2KHR Type; +}; + +// Map type VkDeviceImageSubresourceInfoKHR to id VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceImageSubresourceInfoKHR Type; +}; + +// Map type VkSubresourceLayout2KHR to id VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkSubresourceLayout2KHR Type; +}; + +// Map type VkPipelineCreateFlags2CreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineCreateFlags2CreateInfoKHR Type; +}; + +// Map type VkBufferUsageFlags2CreateInfoKHR to id VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferUsageFlags2CreateInfoKHR Type; +}; + +// Map type VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR Type; +}; + +// Map type VkPhysicalDevicePipelineBinaryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelineBinaryFeaturesKHR Type; +}; + +// Map type VkPhysicalDevicePipelineBinaryPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelineBinaryPropertiesKHR Type; +}; + +// Map type VkDevicePipelineBinaryInternalCacheControlKHR to id VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkDevicePipelineBinaryInternalCacheControlKHR Type; +}; + +// Map type VkPipelineBinaryKeyKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineBinaryKeyKHR Type; +}; + +// Map type VkPipelineCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineCreateInfoKHR Type; +}; + +// Map type VkPipelineBinaryCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineBinaryCreateInfoKHR Type; +}; + +// Map type VkPipelineBinaryInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineBinaryInfoKHR Type; +}; + +// Map type VkReleaseCapturedPipelineDataInfoKHR to id VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkReleaseCapturedPipelineDataInfoKHR Type; +}; + +// Map type VkPipelineBinaryDataInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineBinaryDataInfoKHR Type; +}; + +// Map type VkPipelineBinaryHandlesInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineBinaryHandlesInfoKHR Type; +}; + +// Map type VkCooperativeMatrixPropertiesKHR to id VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkCooperativeMatrixPropertiesKHR Type; +}; + +// Map type VkPhysicalDeviceCooperativeMatrixFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCooperativeMatrixFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceCooperativeMatrixPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCooperativeMatrixPropertiesKHR Type; +}; + +// Map type VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR Type; +}; + +// Map type VkVideoDecodeAV1ProfileInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeAV1ProfileInfoKHR Type; +}; + +// Map type VkVideoDecodeAV1CapabilitiesKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeAV1CapabilitiesKHR Type; +}; + +// Map type VkVideoDecodeAV1SessionParametersCreateInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeAV1SessionParametersCreateInfoKHR Type; +}; + +// Map type VkVideoDecodeAV1PictureInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeAV1PictureInfoKHR Type; +}; + +// Map type VkVideoDecodeAV1DpbSlotInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoDecodeAV1DpbSlotInfoKHR Type; +}; + +// Map type VkPhysicalDeviceVideoMaintenance1FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVideoMaintenance1FeaturesKHR Type; +}; + +// Map type VkVideoInlineQueryInfoKHR to id VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkVideoInlineQueryInfoKHR Type; +}; + +// Map type VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR Type; +}; + +// Map type VkPipelineVertexInputDivisorStateCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineVertexInputDivisorStateCreateInfoKHR Type; +}; + +// Map type VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceShaderFloatControls2FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderFloatControls2FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceIndexTypeUint8FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceIndexTypeUint8FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceLineRasterizationFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLineRasterizationFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceLineRasterizationPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLineRasterizationPropertiesKHR Type; +}; + +// Map type VkPipelineRasterizationLineStateCreateInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRasterizationLineStateCreateInfoKHR Type; +}; + +// Map type VkCalibratedTimestampInfoKHR to id VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkCalibratedTimestampInfoKHR Type; +}; + +// Map type VkPhysicalDeviceShaderExpectAssumeFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderExpectAssumeFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance6FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMaintenance6FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance6PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMaintenance6PropertiesKHR Type; +}; + +// Map type VkBindMemoryStatusKHR to id VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkBindMemoryStatusKHR Type; +}; + +// Map type VkBindDescriptorSetsInfoKHR to id VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkBindDescriptorSetsInfoKHR Type; +}; + +// Map type VkPushConstantsInfoKHR to id VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPushConstantsInfoKHR Type; +}; + +// Map type VkPushDescriptorSetInfoKHR to id VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPushDescriptorSetInfoKHR Type; +}; + +// Map type VkPushDescriptorSetWithTemplateInfoKHR to id VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPushDescriptorSetWithTemplateInfoKHR Type; +}; + +// Map type VkSetDescriptorBufferOffsetsInfoEXT to id VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSetDescriptorBufferOffsetsInfoEXT Type; +}; + +// Map type VkBindDescriptorBufferEmbeddedSamplersInfoEXT to id VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkBindDescriptorBufferEmbeddedSamplersInfoEXT Type; +}; + +// Map type VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance7FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMaintenance7FeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMaintenance7PropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMaintenance7PropertiesKHR Type; +}; + +// Map type VkPhysicalDeviceLayeredApiPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLayeredApiPropertiesKHR Type; +}; + +// Map type VkPhysicalDeviceLayeredApiPropertiesListKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLayeredApiPropertiesListKHR Type; +}; + +// Map type VkPhysicalDeviceLayeredApiVulkanPropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLayeredApiVulkanPropertiesKHR Type; +}; + +// Map type VkDebugReportCallbackCreateInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDebugReportCallbackCreateInfoEXT Type; +}; + +// Map type VkPipelineRasterizationStateRasterizationOrderAMD to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRasterizationStateRasterizationOrderAMD Type; +}; + +// Map type VkDebugMarkerObjectNameInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDebugMarkerObjectNameInfoEXT Type; +}; + +// Map type VkDebugMarkerObjectTagInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDebugMarkerObjectTagInfoEXT Type; +}; + +// Map type VkDebugMarkerMarkerInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDebugMarkerMarkerInfoEXT Type; +}; + +// Map type VkDedicatedAllocationImageCreateInfoNV to id VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkDedicatedAllocationImageCreateInfoNV Type; +}; + +// Map type VkDedicatedAllocationBufferCreateInfoNV to id VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkDedicatedAllocationBufferCreateInfoNV Type; +}; + +// Map type VkDedicatedAllocationMemoryAllocateInfoNV to id VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkDedicatedAllocationMemoryAllocateInfoNV Type; +}; + +// Map type VkPhysicalDeviceTransformFeedbackFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceTransformFeedbackFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceTransformFeedbackPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceTransformFeedbackPropertiesEXT Type; +}; + +// Map type VkPipelineRasterizationStateStreamCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRasterizationStateStreamCreateInfoEXT Type; +}; + +// Map type VkCuModuleCreateInfoNVX to id VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX; +}; + +template <> struct LvlSTypeMap { + typedef VkCuModuleCreateInfoNVX Type; +}; + +// Map type VkCuFunctionCreateInfoNVX to id VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX; +}; + +template <> struct LvlSTypeMap { + typedef VkCuFunctionCreateInfoNVX Type; +}; + +// Map type VkCuLaunchInfoNVX to id VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX; +}; + +template <> struct LvlSTypeMap { + typedef VkCuLaunchInfoNVX Type; +}; + +// Map type VkImageViewHandleInfoNVX to id VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX; +}; + +template <> struct LvlSTypeMap { + typedef VkImageViewHandleInfoNVX Type; +}; + +// Map type VkImageViewAddressPropertiesNVX to id VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX; +}; + +template <> struct LvlSTypeMap { + typedef VkImageViewAddressPropertiesNVX Type; +}; + +// Map type VkTextureLODGatherFormatPropertiesAMD to id VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkTextureLODGatherFormatPropertiesAMD Type; +}; + +#ifdef VK_USE_PLATFORM_GGP +// Map type VkStreamDescriptorSurfaceCreateInfoGGP to id VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; +}; + +template <> struct LvlSTypeMap { + typedef VkStreamDescriptorSurfaceCreateInfoGGP Type; +}; + +#endif // VK_USE_PLATFORM_GGP +// Map type VkPhysicalDeviceCornerSampledImageFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCornerSampledImageFeaturesNV Type; +}; + +// Map type VkExternalMemoryImageCreateInfoNV to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalMemoryImageCreateInfoNV Type; +}; + +// Map type VkExportMemoryAllocateInfoNV to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMemoryAllocateInfoNV Type; +}; + +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkImportMemoryWin32HandleInfoNV to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMemoryWin32HandleInfoNV Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkExportMemoryWin32HandleInfoNV to id VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMemoryWin32HandleInfoNV Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkWin32KeyedMutexAcquireReleaseInfoNV to id VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkWin32KeyedMutexAcquireReleaseInfoNV Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +// Map type VkValidationFlagsEXT to id VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkValidationFlagsEXT Type; +}; + +#ifdef VK_USE_PLATFORM_VI_NN +// Map type VkViSurfaceCreateInfoNN to id VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN; +}; + +template <> struct LvlSTypeMap { + typedef VkViSurfaceCreateInfoNN Type; +}; + +#endif // VK_USE_PLATFORM_VI_NN +// Map type VkImageViewASTCDecodeModeEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageViewASTCDecodeModeEXT Type; +}; + +// Map type VkPhysicalDeviceASTCDecodeFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceASTCDecodeFeaturesEXT Type; +}; + +// Map type VkPhysicalDevicePipelineRobustnessFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelineRobustnessFeaturesEXT Type; +}; + +// Map type VkPhysicalDevicePipelineRobustnessPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelineRobustnessPropertiesEXT Type; +}; + +// Map type VkPipelineRobustnessCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRobustnessCreateInfoEXT Type; +}; + +// Map type VkConditionalRenderingBeginInfoEXT to id VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkConditionalRenderingBeginInfoEXT Type; +}; + +// Map type VkPhysicalDeviceConditionalRenderingFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceConditionalRenderingFeaturesEXT Type; +}; + +// Map type VkCommandBufferInheritanceConditionalRenderingInfoEXT to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCommandBufferInheritanceConditionalRenderingInfoEXT Type; +}; + +// Map type VkPipelineViewportWScalingStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineViewportWScalingStateCreateInfoNV Type; +}; + +// Map type VkSurfaceCapabilities2EXT to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceCapabilities2EXT Type; +}; + +// Map type VkDisplayPowerInfoEXT to id VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayPowerInfoEXT Type; +}; + +// Map type VkDeviceEventInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceEventInfoEXT Type; +}; + +// Map type VkDisplayEventInfoEXT to id VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayEventInfoEXT Type; +}; + +// Map type VkSwapchainCounterCreateInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainCounterCreateInfoEXT Type; +}; + +// Map type VkPresentTimesInfoGOOGLE to id VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; +}; + +template <> struct LvlSTypeMap { + typedef VkPresentTimesInfoGOOGLE Type; +}; + +// Map type VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX Type; +}; + +// Map type VkPipelineViewportSwizzleStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineViewportSwizzleStateCreateInfoNV Type; +}; + +// Map type VkPhysicalDeviceDiscardRectanglePropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDiscardRectanglePropertiesEXT Type; +}; + +// Map type VkPipelineDiscardRectangleStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineDiscardRectangleStateCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceConservativeRasterizationPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceConservativeRasterizationPropertiesEXT Type; +}; + +// Map type VkPipelineRasterizationConservativeStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRasterizationConservativeStateCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceDepthClipEnableFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDepthClipEnableFeaturesEXT Type; +}; + +// Map type VkPipelineRasterizationDepthClipStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRasterizationDepthClipStateCreateInfoEXT Type; +}; + +// Map type VkHdrMetadataEXT to id VK_STRUCTURE_TYPE_HDR_METADATA_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_HDR_METADATA_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkHdrMetadataEXT Type; +}; + +// Map type VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG Type; +}; + +#ifdef VK_USE_PLATFORM_IOS_MVK +// Map type VkIOSSurfaceCreateInfoMVK to id VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; +}; + +template <> struct LvlSTypeMap { + typedef VkIOSSurfaceCreateInfoMVK Type; +}; + +#endif // VK_USE_PLATFORM_IOS_MVK +#ifdef VK_USE_PLATFORM_MACOS_MVK +// Map type VkMacOSSurfaceCreateInfoMVK to id VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; +}; + +template <> struct LvlSTypeMap { + typedef VkMacOSSurfaceCreateInfoMVK Type; +}; + +#endif // VK_USE_PLATFORM_MACOS_MVK +// Map type VkDebugUtilsLabelEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDebugUtilsLabelEXT Type; +}; + +// Map type VkDebugUtilsObjectNameInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDebugUtilsObjectNameInfoEXT Type; +}; + +// Map type VkDebugUtilsMessengerCallbackDataEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDebugUtilsMessengerCallbackDataEXT Type; +}; + +// Map type VkDebugUtilsMessengerCreateInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDebugUtilsMessengerCreateInfoEXT Type; +}; + +// Map type VkDebugUtilsObjectTagInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDebugUtilsObjectTagInfoEXT Type; +}; + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkAndroidHardwareBufferUsageANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkAndroidHardwareBufferUsageANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkAndroidHardwareBufferPropertiesANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkAndroidHardwareBufferPropertiesANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkAndroidHardwareBufferFormatPropertiesANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkAndroidHardwareBufferFormatPropertiesANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkImportAndroidHardwareBufferInfoANDROID to id VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkImportAndroidHardwareBufferInfoANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkMemoryGetAndroidHardwareBufferInfoANDROID to id VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryGetAndroidHardwareBufferInfoANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkExternalFormatANDROID to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalFormatANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkAndroidHardwareBufferFormatProperties2ANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkAndroidHardwareBufferFormatProperties2ANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDeviceShaderEnqueueFeaturesAMDX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderEnqueueFeaturesAMDX Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDeviceShaderEnqueuePropertiesAMDX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderEnqueuePropertiesAMDX Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkExecutionGraphPipelineScratchSizeAMDX to id VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX; +}; + +template <> struct LvlSTypeMap { + typedef VkExecutionGraphPipelineScratchSizeAMDX Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkExecutionGraphPipelineCreateInfoAMDX to id VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX; +}; + +template <> struct LvlSTypeMap { + typedef VkExecutionGraphPipelineCreateInfoAMDX Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkPipelineShaderStageNodeCreateInfoAMDX to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineShaderStageNodeCreateInfoAMDX Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +// Map type VkSampleLocationsInfoEXT to id VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSampleLocationsInfoEXT Type; +}; + +// Map type VkRenderPassSampleLocationsBeginInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassSampleLocationsBeginInfoEXT Type; +}; + +// Map type VkPipelineSampleLocationsStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineSampleLocationsStateCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceSampleLocationsPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSampleLocationsPropertiesEXT Type; +}; + +// Map type VkMultisamplePropertiesEXT to id VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMultisamplePropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT Type; +}; + +// Map type VkPipelineColorBlendAdvancedStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineColorBlendAdvancedStateCreateInfoEXT Type; +}; + +// Map type VkPipelineCoverageToColorStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineCoverageToColorStateCreateInfoNV Type; +}; + +// Map type VkPipelineCoverageModulationStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineCoverageModulationStateCreateInfoNV Type; +}; + +// Map type VkPhysicalDeviceShaderSMBuiltinsPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderSMBuiltinsPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceShaderSMBuiltinsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderSMBuiltinsFeaturesNV Type; +}; + +// Map type VkDrmFormatModifierPropertiesListEXT to id VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDrmFormatModifierPropertiesListEXT Type; +}; + +// Map type VkPhysicalDeviceImageDrmFormatModifierInfoEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageDrmFormatModifierInfoEXT Type; +}; + +// Map type VkImageDrmFormatModifierListCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageDrmFormatModifierListCreateInfoEXT Type; +}; + +// Map type VkImageDrmFormatModifierExplicitCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageDrmFormatModifierExplicitCreateInfoEXT Type; +}; + +// Map type VkImageDrmFormatModifierPropertiesEXT to id VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageDrmFormatModifierPropertiesEXT Type; +}; + +// Map type VkDrmFormatModifierPropertiesList2EXT to id VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDrmFormatModifierPropertiesList2EXT Type; +}; + +// Map type VkValidationCacheCreateInfoEXT to id VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkValidationCacheCreateInfoEXT Type; +}; + +// Map type VkShaderModuleValidationCacheCreateInfoEXT to id VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkShaderModuleValidationCacheCreateInfoEXT Type; +}; + +// Map type VkPipelineViewportShadingRateImageStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineViewportShadingRateImageStateCreateInfoNV Type; +}; + +// Map type VkPhysicalDeviceShadingRateImageFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShadingRateImageFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceShadingRateImagePropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShadingRateImagePropertiesNV Type; +}; + +// Map type VkPipelineViewportCoarseSampleOrderStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineViewportCoarseSampleOrderStateCreateInfoNV Type; +}; + +// Map type VkRayTracingShaderGroupCreateInfoNV to id VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkRayTracingShaderGroupCreateInfoNV Type; +}; + +// Map type VkRayTracingPipelineCreateInfoNV to id VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkRayTracingPipelineCreateInfoNV Type; +}; + +// Map type VkGeometryTrianglesNV to id VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkGeometryTrianglesNV Type; +}; + +// Map type VkGeometryAABBNV to id VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkGeometryAABBNV Type; +}; + +// Map type VkGeometryNV to id VK_STRUCTURE_TYPE_GEOMETRY_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GEOMETRY_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkGeometryNV Type; +}; + +// Map type VkAccelerationStructureInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureInfoNV Type; +}; + +// Map type VkAccelerationStructureCreateInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureCreateInfoNV Type; +}; + +// Map type VkBindAccelerationStructureMemoryInfoNV to id VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkBindAccelerationStructureMemoryInfoNV Type; +}; + +// Map type VkWriteDescriptorSetAccelerationStructureNV to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkWriteDescriptorSetAccelerationStructureNV Type; +}; + +// Map type VkAccelerationStructureMemoryRequirementsInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureMemoryRequirementsInfoNV Type; +}; + +// Map type VkPhysicalDeviceRayTracingPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayTracingPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV Type; +}; + +// Map type VkPipelineRepresentativeFragmentTestStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRepresentativeFragmentTestStateCreateInfoNV Type; +}; + +// Map type VkPhysicalDeviceImageViewImageFormatInfoEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageViewImageFormatInfoEXT Type; +}; + +// Map type VkFilterCubicImageViewImageFormatPropertiesEXT to id VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkFilterCubicImageViewImageFormatPropertiesEXT Type; +}; + +// Map type VkImportMemoryHostPointerInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMemoryHostPointerInfoEXT Type; +}; + +// Map type VkMemoryHostPointerPropertiesEXT to id VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryHostPointerPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceExternalMemoryHostPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExternalMemoryHostPropertiesEXT Type; +}; + +// Map type VkPipelineCompilerControlCreateInfoAMD to id VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineCompilerControlCreateInfoAMD Type; +}; + +// Map type VkPhysicalDeviceShaderCorePropertiesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderCorePropertiesAMD Type; +}; + +// Map type VkDeviceMemoryOverallocationCreateInfoAMD to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceMemoryOverallocationCreateInfoAMD Type; +}; + +// Map type VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT Type; +}; + +#ifdef VK_USE_PLATFORM_GGP +// Map type VkPresentFrameTokenGGP to id VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP; +}; + +template <> struct LvlSTypeMap { + typedef VkPresentFrameTokenGGP Type; +}; + +#endif // VK_USE_PLATFORM_GGP +// Map type VkPhysicalDeviceMeshShaderFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMeshShaderFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceMeshShaderPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMeshShaderPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceShaderImageFootprintFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderImageFootprintFeaturesNV Type; +}; + +// Map type VkPipelineViewportExclusiveScissorStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineViewportExclusiveScissorStateCreateInfoNV Type; +}; + +// Map type VkPhysicalDeviceExclusiveScissorFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExclusiveScissorFeaturesNV Type; +}; + +// Map type VkQueueFamilyCheckpointPropertiesNV to id VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkQueueFamilyCheckpointPropertiesNV Type; +}; + +// Map type VkCheckpointDataNV to id VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkCheckpointDataNV Type; +}; + +// Map type VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL Type; +}; + +// Map type VkInitializePerformanceApiInfoINTEL to id VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL; +}; + +template <> struct LvlSTypeMap { + typedef VkInitializePerformanceApiInfoINTEL Type; +}; + +// Map type VkQueryPoolPerformanceQueryCreateInfoINTEL to id VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; +}; + +template <> struct LvlSTypeMap { + typedef VkQueryPoolPerformanceQueryCreateInfoINTEL Type; +}; + +// Map type VkPerformanceMarkerInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL; +}; + +template <> struct LvlSTypeMap { + typedef VkPerformanceMarkerInfoINTEL Type; +}; + +// Map type VkPerformanceStreamMarkerInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL; +}; + +template <> struct LvlSTypeMap { + typedef VkPerformanceStreamMarkerInfoINTEL Type; +}; + +// Map type VkPerformanceOverrideInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL; +}; + +template <> struct LvlSTypeMap { + typedef VkPerformanceOverrideInfoINTEL Type; +}; + +// Map type VkPerformanceConfigurationAcquireInfoINTEL to id VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL; +}; + +template <> struct LvlSTypeMap { + typedef VkPerformanceConfigurationAcquireInfoINTEL Type; +}; + +// Map type VkPhysicalDevicePCIBusInfoPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePCIBusInfoPropertiesEXT Type; +}; + +// Map type VkDisplayNativeHdrSurfaceCapabilitiesAMD to id VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkDisplayNativeHdrSurfaceCapabilitiesAMD Type; +}; + +// Map type VkSwapchainDisplayNativeHdrCreateInfoAMD to id VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainDisplayNativeHdrCreateInfoAMD Type; +}; + +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkImagePipeSurfaceCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkImagePipeSurfaceCreateInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkMetalSurfaceCreateInfoEXT to id VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMetalSurfaceCreateInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +// Map type VkPhysicalDeviceFragmentDensityMapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentDensityMapFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceFragmentDensityMapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentDensityMapPropertiesEXT Type; +}; + +// Map type VkRenderPassFragmentDensityMapCreateInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassFragmentDensityMapCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceShaderCoreProperties2AMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderCoreProperties2AMD Type; +}; + +// Map type VkPhysicalDeviceCoherentMemoryFeaturesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCoherentMemoryFeaturesAMD Type; +}; + +// Map type VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceMemoryBudgetPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMemoryBudgetPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceMemoryPriorityFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMemoryPriorityFeaturesEXT Type; +}; + +// Map type VkMemoryPriorityAllocateInfoEXT to id VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryPriorityAllocateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceBufferDeviceAddressFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT Type; +}; + +// Map type VkBufferDeviceAddressCreateInfoEXT to id VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferDeviceAddressCreateInfoEXT Type; +}; + +// Map type VkValidationFeaturesEXT to id VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkValidationFeaturesEXT Type; +}; + +// Map type VkCooperativeMatrixPropertiesNV to id VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkCooperativeMatrixPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceCooperativeMatrixFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCooperativeMatrixFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceCooperativeMatrixPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCooperativeMatrixPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceCoverageReductionModeFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCoverageReductionModeFeaturesNV Type; +}; + +// Map type VkPipelineCoverageReductionStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineCoverageReductionStateCreateInfoNV Type; +}; + +// Map type VkFramebufferMixedSamplesCombinationNV to id VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkFramebufferMixedSamplesCombinationNV Type; +}; + +// Map type VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceYcbcrImageArraysFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceYcbcrImageArraysFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceProvokingVertexFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceProvokingVertexFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceProvokingVertexPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceProvokingVertexPropertiesEXT Type; +}; + +// Map type VkPipelineRasterizationProvokingVertexStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineRasterizationProvokingVertexStateCreateInfoEXT Type; +}; + +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkSurfaceFullScreenExclusiveInfoEXT to id VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceFullScreenExclusiveInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkSurfaceCapabilitiesFullScreenExclusiveEXT to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceCapabilitiesFullScreenExclusiveEXT Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +// Map type VkSurfaceFullScreenExclusiveWin32InfoEXT to id VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceFullScreenExclusiveWin32InfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_WIN32_KHR +// Map type VkHeadlessSurfaceCreateInfoEXT to id VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkHeadlessSurfaceCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceShaderAtomicFloatFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderAtomicFloatFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceExtendedDynamicStateFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExtendedDynamicStateFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceHostImageCopyFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceHostImageCopyFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceHostImageCopyPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceHostImageCopyPropertiesEXT Type; +}; + +// Map type VkMemoryToImageCopyEXT to id VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryToImageCopyEXT Type; +}; + +// Map type VkImageToMemoryCopyEXT to id VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageToMemoryCopyEXT Type; +}; + +// Map type VkCopyMemoryToImageInfoEXT to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyMemoryToImageInfoEXT Type; +}; + +// Map type VkCopyImageToMemoryInfoEXT to id VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyImageToMemoryInfoEXT Type; +}; + +// Map type VkCopyImageToImageInfoEXT to id VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyImageToImageInfoEXT Type; +}; + +// Map type VkHostImageLayoutTransitionInfoEXT to id VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkHostImageLayoutTransitionInfoEXT Type; +}; + +// Map type VkSubresourceHostMemcpySizeEXT to id VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSubresourceHostMemcpySizeEXT Type; +}; + +// Map type VkHostImageCopyDevicePerformanceQueryEXT to id VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkHostImageCopyDevicePerformanceQueryEXT Type; +}; + +// Map type VkPhysicalDeviceMapMemoryPlacedFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMapMemoryPlacedFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceMapMemoryPlacedPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMapMemoryPlacedPropertiesEXT Type; +}; + +// Map type VkMemoryMapPlacedInfoEXT to id VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryMapPlacedInfoEXT Type; +}; + +// Map type VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT Type; +}; + +// Map type VkSurfacePresentModeEXT to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfacePresentModeEXT Type; +}; + +// Map type VkSurfacePresentScalingCapabilitiesEXT to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfacePresentScalingCapabilitiesEXT Type; +}; + +// Map type VkSurfacePresentModeCompatibilityEXT to id VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfacePresentModeCompatibilityEXT Type; +}; + +// Map type VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT Type; +}; + +// Map type VkSwapchainPresentFenceInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainPresentFenceInfoEXT Type; +}; + +// Map type VkSwapchainPresentModesCreateInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainPresentModesCreateInfoEXT Type; +}; + +// Map type VkSwapchainPresentModeInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainPresentModeInfoEXT Type; +}; + +// Map type VkSwapchainPresentScalingCreateInfoEXT to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainPresentScalingCreateInfoEXT Type; +}; + +// Map type VkReleaseSwapchainImagesInfoEXT to id VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkReleaseSwapchainImagesInfoEXT Type; +}; + +// Map type VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV Type; +}; + +// Map type VkGraphicsShaderGroupCreateInfoNV to id VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkGraphicsShaderGroupCreateInfoNV Type; +}; + +// Map type VkGraphicsPipelineShaderGroupsCreateInfoNV to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkGraphicsPipelineShaderGroupsCreateInfoNV Type; +}; + +// Map type VkIndirectCommandsLayoutTokenNV to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkIndirectCommandsLayoutTokenNV Type; +}; + +// Map type VkIndirectCommandsLayoutCreateInfoNV to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkIndirectCommandsLayoutCreateInfoNV Type; +}; + +// Map type VkGeneratedCommandsInfoNV to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkGeneratedCommandsInfoNV Type; +}; + +// Map type VkGeneratedCommandsMemoryRequirementsInfoNV to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkGeneratedCommandsMemoryRequirementsInfoNV Type; +}; + +// Map type VkPhysicalDeviceInheritedViewportScissorFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceInheritedViewportScissorFeaturesNV Type; +}; + +// Map type VkCommandBufferInheritanceViewportScissorInfoNV to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkCommandBufferInheritanceViewportScissorInfoNV Type; +}; + +// Map type VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT Type; +}; + +// Map type VkRenderPassTransformBeginInfoQCOM to id VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassTransformBeginInfoQCOM Type; +}; + +// Map type VkCommandBufferInheritanceRenderPassTransformInfoQCOM to id VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkCommandBufferInheritanceRenderPassTransformInfoQCOM Type; +}; + +// Map type VkPhysicalDeviceDepthBiasControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDepthBiasControlFeaturesEXT Type; +}; + +// Map type VkDepthBiasInfoEXT to id VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDepthBiasInfoEXT Type; +}; + +// Map type VkDepthBiasRepresentationInfoEXT to id VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDepthBiasRepresentationInfoEXT Type; +}; + +// Map type VkPhysicalDeviceDeviceMemoryReportFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDeviceMemoryReportFeaturesEXT Type; +}; + +// Map type VkDeviceMemoryReportCallbackDataEXT to id VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceMemoryReportCallbackDataEXT Type; +}; + +// Map type VkDeviceDeviceMemoryReportCreateInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceDeviceMemoryReportCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceRobustness2FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRobustness2FeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceRobustness2PropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRobustness2PropertiesEXT Type; +}; + +// Map type VkSamplerCustomBorderColorCreateInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerCustomBorderColorCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceCustomBorderColorPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCustomBorderColorPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceCustomBorderColorFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCustomBorderColorFeaturesEXT Type; +}; + +// Map type VkPhysicalDevicePresentBarrierFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePresentBarrierFeaturesNV Type; +}; + +// Map type VkSurfaceCapabilitiesPresentBarrierNV to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceCapabilitiesPresentBarrierNV Type; +}; + +// Map type VkSwapchainPresentBarrierCreateInfoNV to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainPresentBarrierCreateInfoNV Type; +}; + +// Map type VkPhysicalDeviceDiagnosticsConfigFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDiagnosticsConfigFeaturesNV Type; +}; + +// Map type VkDeviceDiagnosticsConfigCreateInfoNV to id VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceDiagnosticsConfigCreateInfoNV Type; +}; + +// Map type VkCudaModuleCreateInfoNV to id VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkCudaModuleCreateInfoNV Type; +}; + +// Map type VkCudaFunctionCreateInfoNV to id VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkCudaFunctionCreateInfoNV Type; +}; + +// Map type VkCudaLaunchInfoNV to id VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkCudaLaunchInfoNV Type; +}; + +// Map type VkPhysicalDeviceCudaKernelLaunchFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCudaKernelLaunchFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceCudaKernelLaunchPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCudaKernelLaunchPropertiesNV Type; +}; + +// Map type VkQueryLowLatencySupportNV to id VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkQueryLowLatencySupportNV Type; +}; + +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkExportMetalObjectCreateInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMetalObjectCreateInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkExportMetalObjectsInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMetalObjectsInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkExportMetalDeviceInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMetalDeviceInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkExportMetalCommandQueueInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMetalCommandQueueInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkExportMetalBufferInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMetalBufferInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkImportMetalBufferInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMetalBufferInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkExportMetalTextureInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMetalTextureInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkImportMetalTextureInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMetalTextureInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkExportMetalIOSurfaceInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMetalIOSurfaceInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkImportMetalIOSurfaceInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMetalIOSurfaceInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkExportMetalSharedEventInfoEXT to id VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkExportMetalSharedEventInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +#ifdef VK_USE_PLATFORM_METAL_EXT +// Map type VkImportMetalSharedEventInfoEXT to id VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMetalSharedEventInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_METAL_EXT +// Map type VkPhysicalDeviceDescriptorBufferPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDescriptorBufferPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceDescriptorBufferFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDescriptorBufferFeaturesEXT Type; +}; + +// Map type VkDescriptorAddressInfoEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorAddressInfoEXT Type; +}; + +// Map type VkDescriptorBufferBindingInfoEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorBufferBindingInfoEXT Type; +}; + +// Map type VkDescriptorBufferBindingPushDescriptorBufferHandleEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorBufferBindingPushDescriptorBufferHandleEXT Type; +}; + +// Map type VkDescriptorGetInfoEXT to id VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorGetInfoEXT Type; +}; + +// Map type VkBufferCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferCaptureDescriptorDataInfoEXT Type; +}; + +// Map type VkImageCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageCaptureDescriptorDataInfoEXT Type; +}; + +// Map type VkImageViewCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageViewCaptureDescriptorDataInfoEXT Type; +}; + +// Map type VkSamplerCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerCaptureDescriptorDataInfoEXT Type; +}; + +// Map type VkOpaqueCaptureDescriptorDataCreateInfoEXT to id VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkOpaqueCaptureDescriptorDataCreateInfoEXT Type; +}; + +// Map type VkAccelerationStructureCaptureDescriptorDataInfoEXT to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureCaptureDescriptorDataInfoEXT Type; +}; + +// Map type VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT Type; +}; + +// Map type VkGraphicsPipelineLibraryCreateInfoEXT to id VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkGraphicsPipelineLibraryCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD Type; +}; + +// Map type VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV Type; +}; + +// Map type VkPipelineFragmentShadingRateEnumStateCreateInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineFragmentShadingRateEnumStateCreateInfoNV Type; +}; + +// Map type VkAccelerationStructureGeometryMotionTrianglesDataNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureGeometryMotionTrianglesDataNV Type; +}; + +// Map type VkAccelerationStructureMotionInfoNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureMotionInfoNV Type; +}; + +// Map type VkPhysicalDeviceRayTracingMotionBlurFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayTracingMotionBlurFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceFragmentDensityMap2FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentDensityMap2FeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceFragmentDensityMap2PropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentDensityMap2PropertiesEXT Type; +}; + +// Map type VkCopyCommandTransformInfoQCOM to id VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyCommandTransformInfoQCOM Type; +}; + +// Map type VkPhysicalDeviceImageCompressionControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageCompressionControlFeaturesEXT Type; +}; + +// Map type VkImageCompressionControlEXT to id VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageCompressionControlEXT Type; +}; + +// Map type VkImageCompressionPropertiesEXT to id VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageCompressionPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT Type; +}; + +// Map type VkPhysicalDevice4444FormatsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevice4444FormatsFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceFaultFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFaultFeaturesEXT Type; +}; + +// Map type VkDeviceFaultCountsEXT to id VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceFaultCountsEXT Type; +}; + +// Map type VkDeviceFaultInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceFaultInfoEXT Type; +}; + +// Map type VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT Type; +}; + +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT +// Map type VkDirectFBSurfaceCreateInfoEXT to id VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDirectFBSurfaceCreateInfoEXT Type; +}; + +#endif // VK_USE_PLATFORM_DIRECTFB_EXT +// Map type VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT Type; +}; + +// Map type VkMutableDescriptorTypeCreateInfoEXT to id VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMutableDescriptorTypeCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT Type; +}; + +// Map type VkVertexInputBindingDescription2EXT to id VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkVertexInputBindingDescription2EXT Type; +}; + +// Map type VkVertexInputAttributeDescription2EXT to id VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkVertexInputAttributeDescription2EXT Type; +}; + +// Map type VkPhysicalDeviceDrmPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDrmPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceAddressBindingReportFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceAddressBindingReportFeaturesEXT Type; +}; + +// Map type VkDeviceAddressBindingCallbackDataEXT to id VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceAddressBindingCallbackDataEXT Type; +}; + +// Map type VkPhysicalDeviceDepthClipControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDepthClipControlFeaturesEXT Type; +}; + +// Map type VkPipelineViewportDepthClipControlCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineViewportDepthClipControlCreateInfoEXT Type; +}; + +// Map type VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT Type; +}; + +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkImportMemoryZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMemoryZirconHandleInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkMemoryZirconHandlePropertiesFUCHSIA to id VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryZirconHandlePropertiesFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkMemoryGetZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryGetZirconHandleInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkImportSemaphoreZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkImportSemaphoreZirconHandleInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkSemaphoreGetZirconHandleInfoFUCHSIA to id VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkSemaphoreGetZirconHandleInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkBufferCollectionCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferCollectionCreateInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkImportMemoryBufferCollectionFUCHSIA to id VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkImportMemoryBufferCollectionFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkBufferCollectionImageCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferCollectionImageCreateInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkBufferCollectionConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferCollectionConstraintsInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkBufferConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferConstraintsInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkBufferCollectionBufferCreateInfoFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferCollectionBufferCreateInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkSysmemColorSpaceFUCHSIA to id VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkSysmemColorSpaceFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkBufferCollectionPropertiesFUCHSIA to id VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkBufferCollectionPropertiesFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkImageFormatConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkImageFormatConstraintsInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +#ifdef VK_USE_PLATFORM_FUCHSIA +// Map type VkImageConstraintsInfoFUCHSIA to id VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA; +}; + +template <> struct LvlSTypeMap { + typedef VkImageConstraintsInfoFUCHSIA Type; +}; + +#endif // VK_USE_PLATFORM_FUCHSIA +// Map type VkSubpassShadingPipelineCreateInfoHUAWEI to id VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI; +}; + +template <> struct LvlSTypeMap { + typedef VkSubpassShadingPipelineCreateInfoHUAWEI Type; +}; + +// Map type VkPhysicalDeviceSubpassShadingFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSubpassShadingFeaturesHUAWEI Type; +}; + +// Map type VkPhysicalDeviceSubpassShadingPropertiesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSubpassShadingPropertiesHUAWEI Type; +}; + +// Map type VkPhysicalDeviceInvocationMaskFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceInvocationMaskFeaturesHUAWEI Type; +}; + +// Map type VkMemoryGetRemoteAddressInfoNV to id VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkMemoryGetRemoteAddressInfoNV Type; +}; + +// Map type VkPhysicalDeviceExternalMemoryRDMAFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExternalMemoryRDMAFeaturesNV Type; +}; + +// Map type VkPipelinePropertiesIdentifierEXT to id VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelinePropertiesIdentifierEXT Type; +}; + +// Map type VkPhysicalDevicePipelinePropertiesFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelinePropertiesFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceFrameBoundaryFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFrameBoundaryFeaturesEXT Type; +}; + +// Map type VkFrameBoundaryEXT to id VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkFrameBoundaryEXT Type; +}; + +// Map type VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT Type; +}; + +// Map type VkSubpassResolvePerformanceQueryEXT to id VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSubpassResolvePerformanceQueryEXT Type; +}; + +// Map type VkMultisampledRenderToSingleSampledInfoEXT to id VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMultisampledRenderToSingleSampledInfoEXT Type; +}; + +// Map type VkPhysicalDeviceExtendedDynamicState2FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExtendedDynamicState2FeaturesEXT Type; +}; + +#ifdef VK_USE_PLATFORM_SCREEN_QNX +// Map type VkScreenSurfaceCreateInfoQNX to id VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX; +}; + +template <> struct LvlSTypeMap { + typedef VkScreenSurfaceCreateInfoQNX Type; +}; + +#endif // VK_USE_PLATFORM_SCREEN_QNX +// Map type VkPhysicalDeviceColorWriteEnableFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceColorWriteEnableFeaturesEXT Type; +}; + +// Map type VkPipelineColorWriteCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineColorWriteCreateInfoEXT Type; +}; + +// Map type VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceImageViewMinLodFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageViewMinLodFeaturesEXT Type; +}; + +// Map type VkImageViewMinLodCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageViewMinLodCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceMultiDrawFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMultiDrawFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceMultiDrawPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMultiDrawPropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceImage2DViewOf3DFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImage2DViewOf3DFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceShaderTileImageFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderTileImageFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceShaderTileImagePropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderTileImagePropertiesEXT Type; +}; + +// Map type VkMicromapBuildInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMicromapBuildInfoEXT Type; +}; + +// Map type VkMicromapCreateInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMicromapCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceOpacityMicromapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceOpacityMicromapFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceOpacityMicromapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceOpacityMicromapPropertiesEXT Type; +}; + +// Map type VkMicromapVersionInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMicromapVersionInfoEXT Type; +}; + +// Map type VkCopyMicromapToMemoryInfoEXT to id VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyMicromapToMemoryInfoEXT Type; +}; + +// Map type VkCopyMemoryToMicromapInfoEXT to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyMemoryToMicromapInfoEXT Type; +}; + +// Map type VkCopyMicromapInfoEXT to id VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyMicromapInfoEXT Type; +}; + +// Map type VkMicromapBuildSizesInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMicromapBuildSizesInfoEXT Type; +}; + +// Map type VkAccelerationStructureTrianglesOpacityMicromapEXT to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureTrianglesOpacityMicromapEXT Type; +}; + +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDeviceDisplacementMicromapFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDisplacementMicromapFeaturesNV Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDeviceDisplacementMicromapPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDisplacementMicromapPropertiesNV Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +#ifdef VK_ENABLE_BETA_EXTENSIONS +// Map type VkAccelerationStructureTrianglesDisplacementMicromapNV to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureTrianglesDisplacementMicromapNV Type; +}; + +#endif // VK_ENABLE_BETA_EXTENSIONS +// Map type VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI Type; +}; + +// Map type VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI Type; +}; + +// Map type VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI Type; +}; + +// Map type VkPhysicalDeviceBorderColorSwizzleFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceBorderColorSwizzleFeaturesEXT Type; +}; + +// Map type VkSamplerBorderColorComponentMappingCreateInfoEXT to id VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerBorderColorComponentMappingCreateInfoEXT Type; +}; + +// Map type VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceShaderCorePropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderCorePropertiesARM Type; +}; + +// Map type VkDeviceQueueShaderCoreControlCreateInfoARM to id VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceQueueShaderCoreControlCreateInfoARM Type; +}; + +// Map type VkPhysicalDeviceSchedulingControlsFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSchedulingControlsFeaturesARM Type; +}; + +// Map type VkPhysicalDeviceSchedulingControlsPropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSchedulingControlsPropertiesARM Type; +}; + +// Map type VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT Type; +}; + +// Map type VkImageViewSlicedCreateInfoEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkImageViewSlicedCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE Type; +}; + +// Map type VkDescriptorSetBindingReferenceVALVE to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorSetBindingReferenceVALVE Type; +}; + +// Map type VkDescriptorSetLayoutHostMappingInfoVALVE to id VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; +}; + +template <> struct LvlSTypeMap { + typedef VkDescriptorSetLayoutHostMappingInfoVALVE Type; +}; + +// Map type VkPhysicalDeviceDepthClampZeroOneFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDepthClampZeroOneFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceRenderPassStripedFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRenderPassStripedFeaturesARM Type; +}; + +// Map type VkPhysicalDeviceRenderPassStripedPropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRenderPassStripedPropertiesARM Type; +}; + +// Map type VkRenderPassStripeInfoARM to id VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassStripeInfoARM Type; +}; + +// Map type VkRenderPassStripeBeginInfoARM to id VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassStripeBeginInfoARM Type; +}; + +// Map type VkRenderPassStripeSubmitInfoARM to id VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassStripeSubmitInfoARM Type; +}; + +// Map type VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM Type; +}; + +// Map type VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM Type; +}; + +// Map type VkSubpassFragmentDensityMapOffsetEndInfoQCOM to id VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkSubpassFragmentDensityMapOffsetEndInfoQCOM Type; +}; + +// Map type VkPhysicalDeviceCopyMemoryIndirectFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCopyMemoryIndirectFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceCopyMemoryIndirectPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceMemoryDecompressionFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMemoryDecompressionFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceMemoryDecompressionPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMemoryDecompressionPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV Type; +}; + +// Map type VkComputePipelineIndirectBufferInfoNV to id VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkComputePipelineIndirectBufferInfoNV Type; +}; + +// Map type VkPipelineIndirectDeviceAddressInfoNV to id VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineIndirectDeviceAddressInfoNV Type; +}; + +// Map type VkPhysicalDeviceLinearColorAttachmentFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLinearColorAttachmentFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT Type; +}; + +// Map type VkImageViewSampleWeightCreateInfoQCOM to id VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkImageViewSampleWeightCreateInfoQCOM Type; +}; + +// Map type VkPhysicalDeviceImageProcessingFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageProcessingFeaturesQCOM Type; +}; + +// Map type VkPhysicalDeviceImageProcessingPropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageProcessingPropertiesQCOM Type; +}; + +// Map type VkPhysicalDeviceNestedCommandBufferFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceNestedCommandBufferFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceNestedCommandBufferPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceNestedCommandBufferPropertiesEXT Type; +}; + +// Map type VkExternalMemoryAcquireUnmodifiedEXT to id VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalMemoryAcquireUnmodifiedEXT Type; +}; + +// Map type VkPhysicalDeviceExtendedDynamicState3FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExtendedDynamicState3FeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceExtendedDynamicState3PropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExtendedDynamicState3PropertiesEXT Type; +}; + +// Map type VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT Type; +}; + +// Map type VkRenderPassCreationControlEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassCreationControlEXT Type; +}; + +// Map type VkRenderPassCreationFeedbackCreateInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassCreationFeedbackCreateInfoEXT Type; +}; + +// Map type VkRenderPassSubpassFeedbackCreateInfoEXT to id VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkRenderPassSubpassFeedbackCreateInfoEXT Type; +}; + +// Map type VkDirectDriverLoadingInfoLUNARG to id VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG; +}; + +template <> struct LvlSTypeMap { + typedef VkDirectDriverLoadingInfoLUNARG Type; +}; + +// Map type VkDirectDriverLoadingListLUNARG to id VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG; +}; + +template <> struct LvlSTypeMap { + typedef VkDirectDriverLoadingListLUNARG Type; +}; + +// Map type VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT Type; +}; + +// Map type VkPipelineShaderStageModuleIdentifierCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineShaderStageModuleIdentifierCreateInfoEXT Type; +}; + +// Map type VkShaderModuleIdentifierEXT to id VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkShaderModuleIdentifierEXT Type; +}; + +// Map type VkPhysicalDeviceOpticalFlowFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceOpticalFlowFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceOpticalFlowPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceOpticalFlowPropertiesNV Type; +}; + +// Map type VkOpticalFlowImageFormatInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowImageFormatInfoNV Type; +}; + +// Map type VkOpticalFlowImageFormatPropertiesNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowImageFormatPropertiesNV Type; +}; + +// Map type VkOpticalFlowSessionCreateInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowSessionCreateInfoNV Type; +}; + +// Map type VkOpticalFlowSessionCreatePrivateDataInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowSessionCreatePrivateDataInfoNV Type; +}; + +// Map type VkOpticalFlowExecuteInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowExecuteInfoNV Type; +}; + +// Map type VkPhysicalDeviceLegacyDitheringFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLegacyDitheringFeaturesEXT Type; +}; + +// Map type VkPhysicalDevicePipelineProtectedAccessFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelineProtectedAccessFeaturesEXT Type; +}; + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkPhysicalDeviceExternalFormatResolveFeaturesANDROID to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExternalFormatResolveFeaturesANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkPhysicalDeviceExternalFormatResolvePropertiesANDROID to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExternalFormatResolvePropertiesANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +#ifdef VK_USE_PLATFORM_ANDROID_KHR +// Map type VkAndroidHardwareBufferFormatResolvePropertiesANDROID to id VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID; +}; + +template <> struct LvlSTypeMap { + typedef VkAndroidHardwareBufferFormatResolvePropertiesANDROID Type; +}; + +#endif // VK_USE_PLATFORM_ANDROID_KHR +// Map type VkPhysicalDeviceAntiLagFeaturesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceAntiLagFeaturesAMD Type; +}; + +// Map type VkAntiLagPresentationInfoAMD to id VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkAntiLagPresentationInfoAMD Type; +}; + +// Map type VkAntiLagDataAMD to id VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD; +}; + +template <> struct LvlSTypeMap { + typedef VkAntiLagDataAMD Type; +}; + +// Map type VkPhysicalDeviceShaderObjectFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderObjectFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceShaderObjectPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderObjectPropertiesEXT Type; +}; + +// Map type VkShaderCreateInfoEXT to id VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkShaderCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceTilePropertiesFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceTilePropertiesFeaturesQCOM Type; +}; + +// Map type VkTilePropertiesQCOM to id VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkTilePropertiesQCOM Type; +}; + +// Map type VkPhysicalDeviceAmigoProfilingFeaturesSEC to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceAmigoProfilingFeaturesSEC Type; +}; + +// Map type VkAmigoProfilingSubmitInfoSEC to id VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC; +}; + +template <> struct LvlSTypeMap { + typedef VkAmigoProfilingSubmitInfoSEC Type; +}; + +// Map type VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM Type; +}; + +// Map type VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV Type; +}; + +// Map type VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV Type; +}; + +// Map type VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT Type; +}; + +// Map type VkLayerSettingsCreateInfoEXT to id VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkLayerSettingsCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM Type; +}; + +// Map type VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM Type; +}; + +// Map type VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT Type; +}; + +// Map type VkLatencySleepModeInfoNV to id VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkLatencySleepModeInfoNV Type; +}; + +// Map type VkLatencySleepInfoNV to id VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkLatencySleepInfoNV Type; +}; + +// Map type VkSetLatencyMarkerInfoNV to id VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkSetLatencyMarkerInfoNV Type; +}; + +// Map type VkLatencyTimingsFrameReportNV to id VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkLatencyTimingsFrameReportNV Type; +}; + +// Map type VkGetLatencyMarkerInfoNV to id VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkGetLatencyMarkerInfoNV Type; +}; + +// Map type VkLatencySubmissionPresentIdNV to id VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkLatencySubmissionPresentIdNV Type; +}; + +// Map type VkSwapchainLatencyCreateInfoNV to id VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainLatencyCreateInfoNV Type; +}; + +// Map type VkOutOfBandQueueTypeInfoNV to id VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOutOfBandQueueTypeInfoNV Type; +}; + +// Map type VkLatencySurfaceCapabilitiesNV to id VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkLatencySurfaceCapabilitiesNV Type; +}; + +// Map type VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM Type; +}; + +// Map type VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM to id VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM Type; +}; + +// Map type VkPhysicalDevicePerStageDescriptorSetFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePerStageDescriptorSetFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceImageProcessing2FeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageProcessing2FeaturesQCOM Type; +}; + +// Map type VkPhysicalDeviceImageProcessing2PropertiesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageProcessing2PropertiesQCOM Type; +}; + +// Map type VkSamplerBlockMatchWindowCreateInfoQCOM to id VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerBlockMatchWindowCreateInfoQCOM Type; +}; + +// Map type VkPhysicalDeviceCubicWeightsFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCubicWeightsFeaturesQCOM Type; +}; + +// Map type VkSamplerCubicWeightsCreateInfoQCOM to id VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerCubicWeightsCreateInfoQCOM Type; +}; + +// Map type VkBlitImageCubicWeightsInfoQCOM to id VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkBlitImageCubicWeightsInfoQCOM Type; +}; + +// Map type VkPhysicalDeviceYcbcrDegammaFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceYcbcrDegammaFeaturesQCOM Type; +}; + +// Map type VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM to id VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM Type; +}; + +// Map type VkPhysicalDeviceCubicClampFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCubicClampFeaturesQCOM Type; +}; + +// Map type VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT Type; +}; + +#ifdef VK_USE_PLATFORM_SCREEN_QNX +// Map type VkScreenBufferPropertiesQNX to id VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX; +}; + +template <> struct LvlSTypeMap { + typedef VkScreenBufferPropertiesQNX Type; +}; + +#endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_SCREEN_QNX +// Map type VkScreenBufferFormatPropertiesQNX to id VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX; +}; + +template <> struct LvlSTypeMap { + typedef VkScreenBufferFormatPropertiesQNX Type; +}; + +#endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_SCREEN_QNX +// Map type VkImportScreenBufferInfoQNX to id VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX; +}; + +template <> struct LvlSTypeMap { + typedef VkImportScreenBufferInfoQNX Type; +}; + +#endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_SCREEN_QNX +// Map type VkExternalFormatQNX to id VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX; +}; + +template <> struct LvlSTypeMap { + typedef VkExternalFormatQNX Type; +}; + +#endif // VK_USE_PLATFORM_SCREEN_QNX +#ifdef VK_USE_PLATFORM_SCREEN_QNX +// Map type VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX Type; +}; + +#endif // VK_USE_PLATFORM_SCREEN_QNX +// Map type VkPhysicalDeviceLayeredDriverPropertiesMSFT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceLayeredDriverPropertiesMSFT Type; +}; + +// Map type VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceRawAccessChainsFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRawAccessChainsFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceCommandBufferInheritanceFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceCommandBufferInheritanceFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceRayTracingValidationFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayTracingValidationFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT Type; +}; + +// Map type VkGeneratedCommandsMemoryRequirementsInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkGeneratedCommandsMemoryRequirementsInfoEXT Type; +}; + +// Map type VkIndirectExecutionSetPipelineInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkIndirectExecutionSetPipelineInfoEXT Type; +}; + +// Map type VkIndirectExecutionSetShaderLayoutInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkIndirectExecutionSetShaderLayoutInfoEXT Type; +}; + +// Map type VkIndirectExecutionSetShaderInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkIndirectExecutionSetShaderInfoEXT Type; +}; + +// Map type VkIndirectExecutionSetCreateInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkIndirectExecutionSetCreateInfoEXT Type; +}; + +// Map type VkGeneratedCommandsInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkGeneratedCommandsInfoEXT Type; +}; + +// Map type VkWriteIndirectExecutionSetPipelineEXT to id VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkWriteIndirectExecutionSetPipelineEXT Type; +}; + +// Map type VkIndirectCommandsLayoutTokenEXT to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkIndirectCommandsLayoutTokenEXT Type; +}; + +// Map type VkIndirectCommandsLayoutCreateInfoEXT to id VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkIndirectCommandsLayoutCreateInfoEXT Type; +}; + +// Map type VkGeneratedCommandsPipelineInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkGeneratedCommandsPipelineInfoEXT Type; +}; + +// Map type VkGeneratedCommandsShaderInfoEXT to id VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkGeneratedCommandsShaderInfoEXT Type; +}; + +// Map type VkWriteIndirectExecutionSetShaderEXT to id VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkWriteIndirectExecutionSetShaderEXT Type; +}; + +// Map type VkPhysicalDeviceImageAlignmentControlFeaturesMESA to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageAlignmentControlFeaturesMESA Type; +}; + +// Map type VkPhysicalDeviceImageAlignmentControlPropertiesMESA to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceImageAlignmentControlPropertiesMESA Type; +}; + +// Map type VkImageAlignmentControlCreateInfoMESA to id VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; +}; + +template <> struct LvlSTypeMap { + typedef VkImageAlignmentControlCreateInfoMESA Type; +}; + +// Map type VkPhysicalDeviceDepthClampControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceDepthClampControlFeaturesEXT Type; +}; + +// Map type VkPipelineViewportDepthClampControlCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPipelineViewportDepthClampControlCreateInfoEXT Type; +}; + +// Map type VkAccelerationStructureGeometryTrianglesDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureGeometryTrianglesDataKHR Type; +}; + +// Map type VkAccelerationStructureGeometryAabbsDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureGeometryAabbsDataKHR Type; +}; + +// Map type VkAccelerationStructureGeometryInstancesDataKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureGeometryInstancesDataKHR Type; +}; + +// Map type VkAccelerationStructureGeometryKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureGeometryKHR Type; +}; + +// Map type VkAccelerationStructureBuildGeometryInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureBuildGeometryInfoKHR Type; +}; + +// Map type VkAccelerationStructureCreateInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureCreateInfoKHR Type; +}; + +// Map type VkWriteDescriptorSetAccelerationStructureKHR to id VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkWriteDescriptorSetAccelerationStructureKHR Type; +}; + +// Map type VkPhysicalDeviceAccelerationStructureFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceAccelerationStructureFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceAccelerationStructurePropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceAccelerationStructurePropertiesKHR Type; +}; + +// Map type VkAccelerationStructureDeviceAddressInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureDeviceAddressInfoKHR Type; +}; + +// Map type VkAccelerationStructureVersionInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureVersionInfoKHR Type; +}; + +// Map type VkCopyAccelerationStructureToMemoryInfoKHR to id VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyAccelerationStructureToMemoryInfoKHR Type; +}; + +// Map type VkCopyMemoryToAccelerationStructureInfoKHR to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyMemoryToAccelerationStructureInfoKHR Type; +}; + +// Map type VkCopyAccelerationStructureInfoKHR to id VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyAccelerationStructureInfoKHR Type; +}; + +// Map type VkAccelerationStructureBuildSizesInfoKHR to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureBuildSizesInfoKHR Type; +}; + +// Map type VkRayTracingShaderGroupCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkRayTracingShaderGroupCreateInfoKHR Type; +}; + +// Map type VkRayTracingPipelineInterfaceCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkRayTracingPipelineInterfaceCreateInfoKHR Type; +}; + +// Map type VkRayTracingPipelineCreateInfoKHR to id VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkRayTracingPipelineCreateInfoKHR Type; +}; + +// Map type VkPhysicalDeviceRayTracingPipelineFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayTracingPipelineFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceRayTracingPipelinePropertiesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayTracingPipelinePropertiesKHR Type; +}; + +// Map type VkPhysicalDeviceRayQueryFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceRayQueryFeaturesKHR Type; +}; + +// Map type VkPhysicalDeviceMeshShaderFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMeshShaderFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceMeshShaderPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceMeshShaderPropertiesEXT Type; +}; + +// 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 const T *lvl_find_in_chain(const void *next) { + const LvlGenericHeader *current = reinterpret_cast(next); + const T *found = nullptr; + while (current) { + if (LvlTypeMap::kSType == current->sType) { + found = reinterpret_cast(current); + current = nullptr; + } else { + current = current->pNext; + } + } + return found; +} +// Find an entry of the given type in the pNext chain +template T *lvl_find_mod_in_chain(void *next) { + LvlGenericModHeader *current = reinterpret_cast(next); + T *found = nullptr; + while (current) { + if (LvlTypeMap::kSType == current->sType) { + found = reinterpret_cast(current); + current = nullptr; + } else { + current = current->pNext; + } + } + return found; +} + +// Init the header of an sType struct with pNext +template T lvl_init_struct(void *p_next) { + T out = {}; + out.sType = LvlTypeMap::kSType; + out.pNext = p_next; + return out; +} + +// Init the header of an sType struct +template T lvl_init_struct() { + T out = {}; + out.sType = LvlTypeMap::kSType; + return out; +} + diff --git a/test/icd/mock_icd.cpp b/test/icd/mock_icd.cpp new file mode 100644 index 0000000000..b5b72b8622 --- /dev/null +++ b/test/icd/mock_icd.cpp @@ -0,0 +1,186 @@ +/* +** Copyright (c) 2015-2018, 2023 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. +*/ + +#include "mock_icd.h" +#include "function_definitions.h" + +namespace vkmock { + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char* funcName) { + // TODO: This function should only care about physical device functions and return nullptr for other functions + const auto& item = name_to_funcptr_map.find(funcName); + if (item != name_to_funcptr_map.end()) { + return reinterpret_cast(item->second); + } + // Mock should intercept all functions so if we get here just return null + return nullptr; +} + +#if defined(__GNUC__) && __GNUC__ >= 4 +#define EXPORT __attribute__((visibility("default"))) +#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) +#define EXPORT __attribute__((visibility("default"))) +#else +#define EXPORT +#endif + +} // namespace vkmock + +extern "C" { + +EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName) { + if (!vkmock::negotiate_loader_icd_interface_called) { + vkmock::loader_interface_version = 1; + } + return vkmock::GetInstanceProcAddr(instance, pName); +} + +EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char* pName) { + return vkmock::GetPhysicalDeviceProcAddr(instance, pName); +} + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion) { + vkmock::negotiate_loader_icd_interface_called = true; + vkmock::loader_interface_version = *pSupportedVersion; + if (*pSupportedVersion > vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION) { + *pSupportedVersion = vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION; + } + return VK_SUCCESS; +} + +EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator) { + vkmock::DestroySurfaceKHR(instance, surface, pAllocator); +} + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, VkSurfaceKHR surface, + VkBool32* pSupported) { + return vkmock::GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); +} + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { + return vkmock::GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); +} + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats) { + return vkmock::GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); +} + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) { + return vkmock::GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); +} + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) { + return vkmock::CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); +} + +#ifdef VK_USE_PLATFORM_XLIB_KHR + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return vkmock::CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); +} +#endif /* VK_USE_PLATFORM_XLIB_KHR */ + +#ifdef VK_USE_PLATFORM_XCB_KHR + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return vkmock::CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); +} +#endif /* VK_USE_PLATFORM_XCB_KHR */ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return vkmock::CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); +} +#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return vkmock::CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); +} +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return vkmock::CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes) { + return vkmock::GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); +} + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + uint32_t* pRectCount, VkRect2D* pRects) { + return vkmock::GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); +} + +#ifdef VK_USE_PLATFORM_VI_NN + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return vkmock::CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); +} +#endif /* VK_USE_PLATFORM_VI_NN */ + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { + return vkmock::GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); +} + +#ifdef VK_USE_PLATFORM_IOS_MVK + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return vkmock::CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); +} +#endif /* VK_USE_PLATFORM_IOS_MVK */ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + +EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { + return vkmock::CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); +} +#endif /* VK_USE_PLATFORM_MACOS_MVK */ + +EXPORT vkmock::TestConfig* mockICD_getTestConfig() { + return &vkmock::test_config; +} + +} // end extern "C" diff --git a/test/icd/mock_icd.h b/test/icd/mock_icd.h new file mode 100644 index 0000000000..000a22e2c2 --- /dev/null +++ b/test/icd/mock_icd.h @@ -0,0 +1,270 @@ +/* +** Copyright (c) 2015-2018, 2023 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. +*/ + +#pragma once + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "vk_video/vulkan_video_codecs_common.h" +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#include "vulkan/vulkan.h" + +#include "vulkan/vk_icd.h" +#include "vk_typemap_helper.h" +#include "mock_icd_test_config.h" + +namespace vkmock +{ + +using mutex_t = std::mutex; +using lock_guard_t = std::lock_guard; +using unique_lock_t = std::unique_lock; + +static mutex_t global_lock; +static uint64_t global_unique_handle = 1; +static const uint32_t SUPPORTED_LOADER_ICD_INTERFACE_VERSION = 5; +static uint32_t loader_interface_version = 0; +static bool negotiate_loader_icd_interface_called = false; +static void* CreateDispObjHandle() +{ + auto handle = new VK_LOADER_DATA; + set_loader_magic_value(handle); + return handle; +} +static void DestroyDispObjHandle(void* handle) +{ + delete reinterpret_cast(handle); +} + +static constexpr uint32_t icd_physical_device_count = 1; +static std::unordered_map> physical_device_map; +static std::unordered_map> display_map; + +// Map device memory handle to any mapped allocations that we'll need to free on unmap +static std::unordered_map> mapped_memory_map; + +// Map device memory allocation handle to the size +static std::unordered_map allocated_memory_size_map; + +static std::unordered_map>> queue_map; +static VkDeviceAddress current_available_address = 0x10000000; +struct BufferState +{ + VkDeviceSize size; + VkDeviceAddress address; +}; +static std::unordered_map> buffer_map; +static std::unordered_map> image_memory_size_map; +static std::unordered_map> command_pool_map; +static std::unordered_map> command_pool_buffer_map; + +static constexpr uint32_t icd_swapchain_image_count = 1; +static std::unordered_map swapchain_image_map; + +// TODO: Would like to codegen this but limits aren't in XML +static VkPhysicalDeviceLimits SetLimits(VkPhysicalDeviceLimits* limits) +{ + limits->maxImageDimension1D = 4096; + limits->maxImageDimension2D = 4096; + limits->maxImageDimension3D = 256; + limits->maxImageDimensionCube = 4096; + limits->maxImageArrayLayers = 256; + limits->maxTexelBufferElements = 65536; + limits->maxUniformBufferRange = 16384; + limits->maxStorageBufferRange = 134217728; + limits->maxPushConstantsSize = 128; + limits->maxMemoryAllocationCount = 4096; + limits->maxSamplerAllocationCount = 4000; + limits->bufferImageGranularity = 1; + limits->sparseAddressSpaceSize = 2147483648; + limits->maxBoundDescriptorSets = 4; + limits->maxPerStageDescriptorSamplers = 16; + limits->maxPerStageDescriptorUniformBuffers = 12; + limits->maxPerStageDescriptorStorageBuffers = 4; + limits->maxPerStageDescriptorSampledImages = 16; + limits->maxPerStageDescriptorStorageImages = 4; + limits->maxPerStageDescriptorInputAttachments = 4; + limits->maxPerStageResources = 128; + limits->maxDescriptorSetSamplers = 96; + limits->maxDescriptorSetUniformBuffers = 72; + limits->maxDescriptorSetUniformBuffersDynamic = 8; + limits->maxDescriptorSetStorageBuffers = 24; + limits->maxDescriptorSetStorageBuffersDynamic = 4; + limits->maxDescriptorSetSampledImages = 96; + limits->maxDescriptorSetStorageImages = 24; + limits->maxDescriptorSetInputAttachments = 4; + limits->maxVertexInputAttributes = 16; + limits->maxVertexInputBindings = 16; + limits->maxVertexInputAttributeOffset = 2047; + limits->maxVertexInputBindingStride = 2048; + limits->maxVertexOutputComponents = 64; + limits->maxTessellationGenerationLevel = 64; + limits->maxTessellationPatchSize = 32; + limits->maxTessellationControlPerVertexInputComponents = 64; + limits->maxTessellationControlPerVertexOutputComponents = 64; + limits->maxTessellationControlPerPatchOutputComponents = 120; + limits->maxTessellationControlTotalOutputComponents = 2048; + limits->maxTessellationEvaluationInputComponents = 64; + limits->maxTessellationEvaluationOutputComponents = 64; + limits->maxGeometryShaderInvocations = 32; + limits->maxGeometryInputComponents = 64; + limits->maxGeometryOutputComponents = 64; + limits->maxGeometryOutputVertices = 256; + limits->maxGeometryTotalOutputComponents = 1024; + limits->maxFragmentInputComponents = 64; + limits->maxFragmentOutputAttachments = 4; + limits->maxFragmentDualSrcAttachments = 1; + limits->maxFragmentCombinedOutputResources = 4; + limits->maxComputeSharedMemorySize = 16384; + limits->maxComputeWorkGroupCount[0] = 65535; + limits->maxComputeWorkGroupCount[1] = 65535; + limits->maxComputeWorkGroupCount[2] = 65535; + limits->maxComputeWorkGroupInvocations = 128; + limits->maxComputeWorkGroupSize[0] = 128; + limits->maxComputeWorkGroupSize[1] = 128; + limits->maxComputeWorkGroupSize[2] = 64; + limits->subPixelPrecisionBits = 4; + limits->subTexelPrecisionBits = 4; + limits->mipmapPrecisionBits = 4; + limits->maxDrawIndexedIndexValue = UINT32_MAX; + limits->maxDrawIndirectCount = UINT16_MAX; + limits->maxSamplerLodBias = 2.0f; + limits->maxSamplerAnisotropy = 16; + limits->maxViewports = 16; + limits->maxViewportDimensions[0] = 4096; + limits->maxViewportDimensions[1] = 4096; + limits->viewportBoundsRange[0] = -8192; + limits->viewportBoundsRange[1] = 8191; + limits->viewportSubPixelBits = 0; + limits->minMemoryMapAlignment = 64; + limits->minTexelBufferOffsetAlignment = 16; + limits->minUniformBufferOffsetAlignment = 16; + limits->minStorageBufferOffsetAlignment = 16; + limits->minTexelOffset = -8; + limits->maxTexelOffset = 7; + limits->minTexelGatherOffset = -8; + limits->maxTexelGatherOffset = 7; + limits->minInterpolationOffset = 0.0f; + limits->maxInterpolationOffset = 0.5f; + limits->subPixelInterpolationOffsetBits = 4; + limits->maxFramebufferWidth = 4096; + limits->maxFramebufferHeight = 4096; + limits->maxFramebufferLayers = 256; + limits->framebufferColorSampleCounts = 0x7F; + limits->framebufferDepthSampleCounts = 0x7F; + limits->framebufferStencilSampleCounts = 0x7F; + limits->framebufferNoAttachmentsSampleCounts = 0x7F; + limits->maxColorAttachments = 4; + limits->sampledImageColorSampleCounts = 0x7F; + limits->sampledImageIntegerSampleCounts = 0x7F; + limits->sampledImageDepthSampleCounts = 0x7F; + limits->sampledImageStencilSampleCounts = 0x7F; + limits->storageImageSampleCounts = 0x7F; + limits->maxSampleMaskWords = 1; + limits->timestampComputeAndGraphics = VK_TRUE; + limits->timestampPeriod = 1; + limits->maxClipDistances = 8; + limits->maxCullDistances = 8; + limits->maxCombinedClipAndCullDistances = 8; + limits->discreteQueuePriorities = 2; + limits->pointSizeRange[0] = 1.0f; + limits->pointSizeRange[1] = 64.0f; + limits->lineWidthRange[0] = 1.0f; + limits->lineWidthRange[1] = 8.0f; + limits->pointSizeGranularity = 1.0f; + limits->lineWidthGranularity = 1.0f; + limits->strictLines = VK_TRUE; + limits->standardSampleLocations = VK_TRUE; + limits->optimalBufferCopyOffsetAlignment = 1; + limits->optimalBufferCopyRowPitchAlignment = 1; + limits->nonCoherentAtomSize = 256; + + return *limits; +} + +void SetBoolArrayTrue(VkBool32* bool_array, uint32_t num_bools) +{ + for (uint32_t i = 0; i < num_bools; ++i) + { + bool_array[i] = VK_TRUE; + } +} + +VkDeviceSize GetImageSizeFromCreateInfo(const VkImageCreateInfo* pCreateInfo) +{ + VkDeviceSize size = pCreateInfo->extent.width; + size *= pCreateInfo->extent.height; + size *= pCreateInfo->extent.depth; + // TODO: A pixel size is 32 bytes. This accounts for the largest possible pixel size of any format. It could be + // changed to more accurate size if need be. + size *= 32; + size *= pCreateInfo->arrayLayers; + size *= (pCreateInfo->mipLevels > 1 ? 2 : 1); + + switch (pCreateInfo->format) + { + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: + size *= 3; + break; + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: + size *= 2; + break; + default: + break; + } + + return size; +} + +typedef void(VKAPI_PTR* PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +static TestConfig test_config; + +} // namespace vkmock diff --git a/test/icd/mock_icd_test_config.h b/test/icd/mock_icd_test_config.h new file mode 100644 index 0000000000..9a72b73297 --- /dev/null +++ b/test/icd/mock_icd_test_config.h @@ -0,0 +1,28 @@ +/* +** Copyright (c) 2015-2018, 2023 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. +*/ + +#pragma once +namespace vkmock +{ + +struct TestConfig +{ + uint32_t device_api_version_override = 0; +}; + +} // namespace vkmock + +typedef vkmock::TestConfig*(VKAPI_PTR* PFN_mockICD_getTestConfig)(); diff --git a/test/known_good/.gitignore b/test/known_good/.gitignore new file mode 100644 index 0000000000..94a2dd146a --- /dev/null +++ b/test/known_good/.gitignore @@ -0,0 +1 @@ +*.json \ No newline at end of file diff --git a/test/known_good/multisample-depth.gfxr b/test/known_good/multisample-depth.gfxr new file mode 100644 index 0000000000000000000000000000000000000000..3dfc3c94215d674fd45f88944527098101b77465 GIT binary patch literal 28209 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 P=z17h8~j|GiS_t@{wt1c literal 0 HcmV?d00001 diff --git a/test/known_good/multisample-depth_macos.gfxr b/test/known_good/multisample-depth_macos.gfxr new file mode 100644 index 0000000000000000000000000000000000000000..f2ef0002f27920151a9574ca3cfb7f3291659ad5 GIT binary patch literal 28152 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 VmUI;pl^Mi$<*Ioo-0Gt&{XY+x?iK(5 literal 0 HcmV?d00001 diff --git a/test/known_good/pipeline-binaries_macos.gfxr b/test/known_good/pipeline-binaries_macos.gfxr new file mode 100644 index 0000000000000000000000000000000000000000..166e12b4269ef1e47859ac7ac507289a8783a6e7 GIT binary patch literal 8836 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 Y8=KUcsU>u&giMDf)xoO|oS2UP13$mBhyVZp literal 0 HcmV?d00001 diff --git a/test/known_good/shader-objects_macos.gfxr b/test/known_good/shader-objects_macos.gfxr new file mode 100644 index 0000000000000000000000000000000000000000..149c0a42ff278c39cd35e37a70cd3a608bf8b7e8 GIT binary patch literal 56335 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 #if defined(_WIN32) #include @@ -39,11 +40,14 @@ #include #include -GFXRECON_BEGIN_NAMESPACE(gfxrecon) +namespace gfxrecon +{ -GFXRECON_BEGIN_NAMESPACE(test) +namespace test +{ -GFXRECON_BEGIN_NAMESPACE(detail) +namespace detail +{ GenericFeaturesPNextNode::GenericFeaturesPNextNode() { @@ -162,23 +166,41 @@ class VulkanFunctions { return true; } + auto library_path = std::getenv("VULKAN_LIBRARY_PATH"); #if defined(__linux__) - library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL); + if (library_path != nullptr) + { + library = dlopen(library_path, RTLD_NOW | RTLD_LOCAL); + } + if (!library) + library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL); if (!library) library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL); #elif defined(__APPLE__) - library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); + if (library_path != nullptr) + { + library = dlopen(library_path, RTLD_NOW | RTLD_LOCAL); + } + if (!library) + library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); if (!library) library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL); if (!library) library = dlopen("libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL); #elif defined(_WIN32) - library = LoadLibrary(TEXT("vulkan-1.dll")); + if (library_path != nullptr) + { + library = LoadLibrary(library_path); + } + if (!library) + library = LoadLibrary(TEXT("vulkan-1.dll")); #else assert(false && "Unsupported platform"); #endif if (!library) + { return false; + } load_func(ptr_vkGetInstanceProcAddr, "vkGetInstanceProcAddr"); return ptr_vkGetInstanceProcAddr != nullptr; } @@ -192,6 +214,7 @@ class VulkanFunctions func_dest = reinterpret_cast(GetProcAddress(library, func_name)); #endif } + void close() { #if defined(__linux__) || defined(__APPLE__) @@ -335,7 +358,7 @@ auto get_vector_noerror(F&& f, Ts&&... ts) -> std::vector return results; } -GFXRECON_END_NAMESPACE(detail) +} // namespace detail const char* to_string_message_severity(VkDebugUtilsMessageSeverityFlagBitsEXT s) { @@ -413,7 +436,8 @@ void destroy_debug_utils_messenger(VkInstance instance, } } -GFXRECON_BEGIN_NAMESPACE(detail) +namespace detail +{ bool check_layer_supported(std::vector const& available_layers, const char* layer_name) { @@ -484,7 +508,7 @@ void setup_pNext_chain(T& structure, std::vector const& str } const char* validation_layer_name = "VK_LAYER_KHRONOS_validation"; -GFXRECON_END_NAMESPACE(detail) +} // namespace detail #define CASE_TO_STRING(CATEGORY, TYPE) \ case CATEGORY::TYPE: \ @@ -806,16 +830,6 @@ Instance InstanceBuilder::build() const extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); } -#if defined(VK_KHR_portability_enumeration) - bool portability_enumeration_support = - detail::check_extension_supported(system.available_extensions, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); - if (portability_enumeration_support) - { - extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); - } -#else - bool portability_enumeration_support = false; -#endif if (!info.headless_context) { auto check_add_window_ext = [&](const char* name) -> bool { @@ -825,20 +839,28 @@ Instance InstanceBuilder::build() const return true; }; bool khr_surface_added = check_add_window_ext("VK_KHR_surface"); + bool added_window_exts = false; + if (std::getenv("GFXRECON_TESTAPP_HEADLESS") != nullptr) + { + added_window_exts = check_add_window_ext("VK_EXT_headless_surface"); + } + else + { #if defined(_WIN32) - bool added_window_exts = check_add_window_ext("VK_KHR_win32_surface"); + added_window_exts = check_add_window_ext("VK_KHR_win32_surface"); #elif defined(__ANDROID__) - bool added_window_exts = check_add_window_ext("VK_KHR_android_surface"); + added_window_exts = check_add_window_ext("VK_KHR_android_surface"); #elif defined(_DIRECT2DISPLAY) - bool added_window_exts = check_add_window_ext("VK_KHR_display"); + added_window_exts = check_add_window_ext("VK_KHR_display"); #elif defined(__linux__) - // make sure all three calls to check_add_window_ext, don't allow short circuiting - bool added_window_exts = check_add_window_ext("VK_KHR_xcb_surface"); - added_window_exts = check_add_window_ext("VK_KHR_xlib_surface") || added_window_exts; - added_window_exts = check_add_window_ext("VK_KHR_wayland_surface") || added_window_exts; + // make sure all three calls to check_add_window_ext, don't allow short circuiting + added_window_exts = check_add_window_ext("VK_KHR_xcb_surface"); + added_window_exts = check_add_window_ext("VK_KHR_xlib_surface") || added_window_exts; + added_window_exts = check_add_window_ext("VK_KHR_wayland_surface") || added_window_exts; #elif defined(__APPLE__) - bool added_window_exts = check_add_window_ext("VK_EXT_metal_surface"); + added_window_exts = check_add_window_ext("VK_EXT_metal_surface"); #endif + } if (!khr_surface_added || !added_window_exts) throw to_exception(InstanceError::windowing_extensions_not_present); } @@ -911,12 +933,6 @@ Instance InstanceBuilder::build() const instance_create_info.ppEnabledExtensionNames = extensions.data(); instance_create_info.enabledLayerCount = static_cast(layers.size()); instance_create_info.ppEnabledLayerNames = layers.data(); -#if defined(VK_KHR_portability_enumeration) - if (portability_enumeration_support) - { - instance_create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR; - } -#endif Instance instance; VkResult res = detail::vulkan_functions().fp_vkCreateInstance( @@ -1123,7 +1139,8 @@ void destroy_debug_messenger(VkInstance const instance, VkDebugUtilsMessengerEXT // ---- Physical Device ---- // -GFXRECON_BEGIN_NAMESPACE(detail) +namespace detail +{ std::vector check_device_extension_support(std::vector const& available_extensions, std::vector const& desired_extensions) @@ -1337,7 +1354,7 @@ std::optional get_present_queue_index(VkPhysicalDevice const return {}; } -GFXRECON_END_NAMESPACE(detail) +} // namespace detail PhysicalDevice PhysicalDeviceSelector::populate_device_details(VkPhysicalDevice vk_phys_device, @@ -2146,7 +2163,8 @@ DeviceBuilder& DeviceBuilder::set_allocation_callbacks(VkAllocationCallbacks* ca // ---- Swapchain ---- // -GFXRECON_BEGIN_NAMESPACE(detail) +namespace detail +{ struct SurfaceSupportDetails { @@ -2291,7 +2309,7 @@ VkExtent2D find_extent(VkSurfaceCapabilitiesKHR const& capabilities, uint32_t de } } -GFXRECON_END_NAMESPACE(detail) +} // namespace detail void destroy_swapchain(Swapchain const& swapchain) { @@ -2717,6 +2735,17 @@ VkSurfaceKHR create_surface_sdl(VkInstance instance, SDL_Window* window, VkAlloc return surface; } +VkSurfaceKHR +create_surface_headless(VkInstance instance, vkb::InstanceDispatchTable& disp, VkAllocationCallbacks* callbacks) +{ + VkSurfaceKHR surface = VK_NULL_HANDLE; + VkHeadlessSurfaceCreateInfoEXT create_info{}; + create_info.sType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT; + VERIFY_VK_RESULT("failed to create headless surface", + disp.createHeadlessSurfaceEXT(&create_info, callbacks, &surface)); + return surface; +} + void create_swapchain(SwapchainBuilder& swapchain_builder, Swapchain& swapchain) { auto new_swapchain = swapchain_builder.set_old_swapchain(swapchain).build(); @@ -2821,7 +2850,10 @@ std::exception sdl_exception() void device_initialization_phase_1(const std::string& window_name, InitInfo& init) { - init.window = create_window_sdl(window_name.data(), true, 1024, 1024); + if (std::getenv("GFXRECON_TESTAPP_HEADLESS") == nullptr) + { + init.window = create_window_sdl(window_name.data(), true, 1024, 1024); + } } void device_initialization_phase_2(InstanceBuilder const& instance_builder, InitInfo& init) @@ -2830,7 +2862,14 @@ void device_initialization_phase_2(InstanceBuilder const& instance_builder, Init init.inst_disp = init.instance.make_table(); - init.surface = create_surface_sdl(init.instance, init.window); + if (std::getenv("GFXRECON_TESTAPP_HEADLESS") == nullptr) + { + init.surface = create_surface_sdl(init.instance, init.window); + } + else + { + init.surface = create_surface_headless(init.instance, init.inst_disp); + } } PhysicalDevice device_initialization_phase_3(PhysicalDeviceSelector& phys_device_selector, InitInfo& init) @@ -2853,12 +2892,47 @@ void device_initialization_phase_5(SwapchainBuilder& swapchain_builder, InitInfo init.swapchain_image_views = init.swapchain.get_image_views(); } +static vkmock::TestConfig* try_load_test_config() +{ + char const* mock_icd_location = std::getenv("GFXRECON_TESTAPP_MOCK_ICD"); + if (mock_icd_location == nullptr) + { + return nullptr; + } +#if defined(__linux__) || defined(__APPLE__) + auto library = dlopen(mock_icd_location, RTLD_NOW | RTLD_LOCAL); + if (library == nullptr) + { + return nullptr; + } + PFN_mockICD_getTestConfig getTestConfig = + reinterpret_cast(dlsym(library, "mockICD_getTestConfig")); +#elif defined(_WIN32) + auto module = LoadLibrary(TEXT(mock_icd_location)); + if (module == nullptr) + { + return nullptr; + } + PFN_mockICD_getTestConfig getTestConfig = + reinterpret_cast(GetProcAddress(module, "mockICD_getTestConfig")); +#else + static_assert(false && "Unsupported platform"); +#endif + if (getTestConfig == nullptr) + { + return nullptr; + } + return getTestConfig(); +} + InitInfo device_initialization(const std::string& window_name) { InitInfo init; device_initialization_phase_1(window_name, init); + init.test_config = try_load_test_config(); + InstanceBuilder instance_builder; device_initialization_phase_2(instance_builder, init); @@ -2882,7 +2956,8 @@ void cleanup_init(InitInfo& init) destroy_device(init.device); destroy_surface(init.instance, init.surface); destroy_instance(init.instance); - destroy_window_sdl(init.window); + if (init.window != nullptr) + destroy_window_sdl(init.window); } void recreate_init_swapchain(SwapchainBuilder& swapchain_builder, InitInfo& init, bool wait_for_idle) @@ -2902,20 +2977,22 @@ void TestAppBase::run(const std::string& window_name) { device_initialization_phase_1(window_name, init); + init.test_config = try_load_test_config(); + InstanceBuilder instance_builder; - configure_instance_builder(instance_builder); + configure_instance_builder(instance_builder, init.test_config); device_initialization_phase_2(instance_builder, init); PhysicalDeviceSelector phys_device_selector(init.instance); - configure_physical_device_selector(phys_device_selector); + configure_physical_device_selector(phys_device_selector, init.test_config); init.physical_device = device_initialization_phase_3(phys_device_selector, init); DeviceBuilder device_builder{ init.physical_device }; - configure_device_builder(device_builder, init.physical_device); + configure_device_builder(device_builder, init.physical_device, init.test_config); device_initialization_phase_4(device_builder, init); SwapchainBuilder swapchain_builder{ init.device }; - configure_swapchain_builder(swapchain_builder); + configure_swapchain_builder(swapchain_builder, init.test_config); device_initialization_phase_5(swapchain_builder, init); setup(); @@ -2947,19 +3024,29 @@ void TestAppBase::run(const std::string& window_name) void TestAppBase::recreate_swapchain(bool wait_for_idle) { SwapchainBuilder swapchain_builder{ init.device }; - configure_swapchain_builder(swapchain_builder); + configure_swapchain_builder(swapchain_builder, init.test_config); recreate_init_swapchain(swapchain_builder, init, wait_for_idle); } void TestAppBase::setup() {} + void TestAppBase::cleanup() {} -void TestAppBase::configure_instance_builder(InstanceBuilder& instance_builder) + +void TestAppBase::configure_instance_builder(InstanceBuilder& instance_builder, vkmock::TestConfig* test_config) { instance_builder.use_default_debug_messenger().request_validation_layers(); } -void TestAppBase::configure_physical_device_selector(PhysicalDeviceSelector& phys_device_selector) {} -void TestAppBase::configure_device_builder(DeviceBuilder& device_builder, PhysicalDevice const& physical_device) {} -void TestAppBase::configure_swapchain_builder(SwapchainBuilder& swapchain_builder) {} + +void TestAppBase::configure_physical_device_selector(PhysicalDeviceSelector& phys_device_selector, + vkmock::TestConfig* test_config) +{} + +void TestAppBase::configure_device_builder(DeviceBuilder& device_builder, + PhysicalDevice const& physical_device, + vkmock::TestConfig* test_config) +{} + +void TestAppBase::configure_swapchain_builder(SwapchainBuilder& swapchain_builder, vkmock::TestConfig* test_config) {} bool DeviceBuilder::enable_extension_if_present(const char* extension) { @@ -2976,6 +3063,6 @@ bool DeviceBuilder::enable_features_if_present(const VkPhysicalDeviceFeatures& f return physical_device.enable_features_if_present(features_to_enable); } -GFXRECON_END_NAMESPACE(test) +} // namespace test -GFXRECON_END_NAMESPACE(gfxrecon) +} // namespace gfxrecon diff --git a/test/test_apps/common/test_app_base.h b/test/test_apps/common/test_app_base.h index 7d1bcf32a3..ccfd059d62 100644 --- a/test/test_apps/common/test_app_base.h +++ b/test/test_apps/common/test_app_base.h @@ -39,7 +39,7 @@ #include #include "test_app_dispatch.h" -#include "util/defines.h" +#include "mock_icd_test_config.h" #ifdef VK_MAKE_API_VERSION #define VKB_MAKE_VK_VERSION(variant, major, minor, patch) VK_MAKE_API_VERSION(variant, major, minor, patch) @@ -63,14 +63,22 @@ #define VKB_VK_API_VERSION_1_0 VKB_MAKE_VK_VERSION(0, 1, 0, 0) #endif -GFXRECON_BEGIN_NAMESPACE(gfxrecon) +namespace vkmock +{ +struct TestConfig; +} + +namespace gfxrecon +{ -GFXRECON_BEGIN_NAMESPACE(test) +namespace test +{ std::exception vulkan_exception(const char* message, VkResult result); std::exception sdl_exception(); -GFXRECON_BEGIN_NAMESPACE(detail) +namespace detail +{ struct GenericFeaturesPNextNode { @@ -122,7 +130,7 @@ struct GenericFeatureChain void combine(GenericFeatureChain const& right) noexcept; }; -GFXRECON_END_NAMESPACE(detail) +} // namespace detail enum class InstanceError { @@ -1007,6 +1015,9 @@ class SwapchainBuilder SDL_Window* create_window_sdl(const char* window_name, bool resizable, int width, int height); void destroy_window_sdl(SDL_Window* window); VkSurfaceKHR create_surface_sdl(VkInstance instance, SDL_Window* window, VkAllocationCallbacks* allocator = nullptr); +VkSurfaceKHR create_surface_headless(VkInstance instance, + vkb::InstanceDispatchTable& disp, + VkAllocationCallbacks* callbacks = nullptr); void create_swapchain(SwapchainBuilder& swapchain_builder, Swapchain& swapchain); VkCommandPool create_command_pool(vkb::DispatchTable const& disp, uint32_t queue_family_index); @@ -1038,8 +1049,9 @@ VkShaderModule readShaderFromFile(vkb::DispatchTable const& disp, const std::str #define VERIFY_VK_RESULT(message, result) \ { \ - if (result != VK_SUCCESS) \ + if (result != VK_SUCCESS) { \ throw gfxrecon::test::vulkan_exception(message, result); \ + } \ } struct InitInfo @@ -1054,6 +1066,7 @@ struct InitInfo Swapchain swapchain; std::vector swapchain_images; std::vector swapchain_image_views; + vkmock::TestConfig* test_config; }; InitInfo device_initialization(const std::string& window_name); @@ -1080,16 +1093,16 @@ class TestAppBase virtual void setup(); virtual bool frame(const int frame_num) = 0; virtual void cleanup(); - virtual void configure_instance_builder(InstanceBuilder& instance_builder); - virtual void configure_physical_device_selector(PhysicalDeviceSelector& phys_device_selector); - virtual void configure_device_builder(DeviceBuilder& device_builder, PhysicalDevice const& physical_device); - virtual void configure_swapchain_builder(SwapchainBuilder& swapchain_builder); + virtual void configure_instance_builder(InstanceBuilder& instance_builder, vkmock::TestConfig* test_config); + virtual void configure_physical_device_selector(PhysicalDeviceSelector& phys_device_selector, vkmock::TestConfig* test_config); + virtual void configure_device_builder(DeviceBuilder& device_builder, PhysicalDevice const& physical_device, vkmock::TestConfig* test_config); + virtual void configure_swapchain_builder(SwapchainBuilder& swapchain_builder, vkmock::TestConfig* test_config); InitInfo init; }; -GFXRECON_END_NAMESPACE(test) +} // namespace test -GFXRECON_END_NAMESPACE(gfxrecon) +} // namespace gfxrecon #endif // GFXRECON_TEST_APP_BASE_H diff --git a/test/test_apps/host-image-copy/CMakeLists.txt b/test/test_apps/host-image-copy/CMakeLists.txt index 10f4597fae..2cf039cdf0 100644 --- a/test/test_apps/host-image-copy/CMakeLists.txt +++ b/test/test_apps/host-image-copy/CMakeLists.txt @@ -26,48 +26,12 @@ # Description: CMake script for host-image-copy test app ############################################################################### -add_executable(gfxrecon-testapp-host-image-copy "") +add_executable(gfxrecon-testapp-host-image-copy app.cpp) -target_sources(gfxrecon-testapp-host-image-copy - PRIVATE - ${CMAKE_CURRENT_LIST_DIR}/app.cpp - ${CMAKE_CURRENT_LIST_DIR}/../common/test_app_base.cpp) - -target_include_directories(gfxrecon-testapp-host-image-copy PUBLIC - ${CMAKE_BINARY_DIR} - ${CMAKE_CURRENT_LIST_DIR}/../common) - -target_link_libraries(gfxrecon-testapp-host-image-copy - gfxrecon_application - gfxrecon_decode - gfxrecon_graphics - gfxrecon_format - gfxrecon_util - SDL3::SDL3 - platform_specific) - -if (MSVC) - # Force inclusion of "gfxrecon_disable_popup_result" variable in linking. - # On 32-bit windows, MSVC prefixes symbols with "_" but on 64-bit windows it doesn't. - if(CMAKE_SIZEOF_VOID_P EQUAL 4) - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:_gfxrecon_disable_popup_result") - else() - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:gfxrecon_disable_popup_result") - endif() -endif() +target_link_libraries(gfxrecon-testapp-host-image-copy gfxrecon-testapp-base) common_build_directives(gfxrecon-testapp-host-image-copy) -add_custom_command( - TARGET gfxrecon-testapp-host-image-copy - POST_BUILD - DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}) -if (WIN32) -add_custom_command(TARGET gfxrecon-testapp-host-image-copy POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ - COMMAND_EXPAND_LISTS) -endif () - -install(TARGETS gfxrecon-testapp-host-image-copy RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) +install(TARGETS gfxrecon-testapp-host-image-copy RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTAPPDIR}/host-image-copy ) add_dependencies(gfxrecon-testapps gfxrecon-testapp-host-image-copy) \ No newline at end of file diff --git a/test/test_apps/host-image-copy/app.cpp b/test/test_apps/host-image-copy/app.cpp index 336b33dd1b..a899ebc151 100644 --- a/test/test_apps/host-image-copy/app.cpp +++ b/test/test_apps/host-image-copy/app.cpp @@ -29,11 +29,14 @@ #include -GFXRECON_BEGIN_NAMESPACE(gfxrecon) +namespace gfxrecon +{ -GFXRECON_BEGIN_NAMESPACE(test_app) +namespace test_app +{ -GFXRECON_BEGIN_NAMESPACE(host_image_copy) +namespace host_image_copy +{ class App : public gfxrecon::test::TestAppBase { @@ -63,10 +66,12 @@ class App : public gfxrecon::test::TestAppBase VkCommandBuffer command_buffer_; VkFence fence_; - void configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector) override; + void configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector, + vkmock::TestConfig*) override; void configure_device_builder(test::DeviceBuilder& device_builder, - test::PhysicalDevice const& physical_device) override; + test::PhysicalDevice const& physical_device, + vkmock::TestConfig*) override; uint32_t find_memory_type(uint32_t memoryTypeBits, VkMemoryPropertyFlags memory_property_flags); void create_buffers_and_images(); @@ -76,14 +81,16 @@ class App : public gfxrecon::test::TestAppBase void setup() override; }; -void App::configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector) +void App::configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector, vkmock::TestConfig*) { phys_device_selector.add_required_extension("VK_KHR_copy_commands2"); phys_device_selector.add_required_extension("VK_KHR_format_feature_flags2"); phys_device_selector.add_required_extension("VK_EXT_host_image_copy"); } -void App::configure_device_builder(test::DeviceBuilder& device_builder, test::PhysicalDevice const& physical_device) +void App::configure_device_builder(test::DeviceBuilder& device_builder, + test::PhysicalDevice const& physical_device, + vkmock::TestConfig*) { host_image_copy_features_.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; host_image_copy_features_.pNext = nullptr; @@ -469,11 +476,11 @@ void App::setup() init.disp.createFence(&fence_create_info, nullptr, &fence_); } -GFXRECON_END_NAMESPACE(host_image_copy) +} // namespace host_image_copy -GFXRECON_END_NAMESPACE(test_app) +} // namespace test_app -GFXRECON_END_NAMESPACE(gfxrecon) +} // namespace gfxrecon int main(int argc, char* argv[]) { @@ -483,7 +490,7 @@ int main(int argc, char* argv[]) app.run("host image copy"); return 0; } - catch (std::exception& e) + catch (const std::exception& e) { std::cout << e.what() << std::endl; return -1; diff --git a/test/test_apps/multisample-depth/CMakeLists.txt b/test/test_apps/multisample-depth/CMakeLists.txt index b02883e9de..17128108b7 100644 --- a/test/test_apps/multisample-depth/CMakeLists.txt +++ b/test/test_apps/multisample-depth/CMakeLists.txt @@ -24,49 +24,12 @@ # Description: CMake script for multisample depth test app ############################################################################### -add_executable(gfxrecon-testapp-multisample-depth "") - -target_sources(gfxrecon-testapp-multisample-depth - PRIVATE - ${CMAKE_CURRENT_LIST_DIR}/app.cpp - ${CMAKE_CURRENT_LIST_DIR}/../common/test_app_base.cpp) - -target_include_directories(gfxrecon-testapp-multisample-depth PUBLIC - ${CMAKE_BINARY_DIR} - ${CMAKE_CURRENT_LIST_DIR}/../common) - -target_link_libraries(gfxrecon-testapp-multisample-depth - vulkan_memory_allocator - gfxrecon_application - gfxrecon_util - SDL3::SDL3 - platform_specific) - -if (MSVC) - # Force inclusion of "gfxrecon_disable_popup_result" variable in linking. - # On 32-bit windows, MSVC prefixes symbols with "_" but on 64-bit windows it doesn't. - if (CMAKE_SIZEOF_VOID_P EQUAL 4) - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:_gfxrecon_disable_popup_result") - else () - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:gfxrecon_disable_popup_result") - endif () -endif () +add_executable(gfxrecon-testapp-multisample-depth app.cpp) +target_link_libraries(gfxrecon-testapp-multisample-depth vulkan_memory_allocator gfxrecon-testapp-base platform_specific) common_build_directives(gfxrecon-testapp-multisample-depth) -add_custom_command( - TARGET gfxrecon-testapp-multisample-depth - POST_BUILD - COMMAND - ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_LIST_DIR}/shaders ${CMAKE_CURRENT_BINARY_DIR} - DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}) -if (WIN32) - add_custom_command(TARGET gfxrecon-testapp-multisample-depth POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ - COMMAND_EXPAND_LISTS) -endif () - -install(TARGETS gfxrecon-testapp-multisample-depth RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) +install(TARGETS gfxrecon-testapp-multisample-depth RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTAPPDIR}/multisample-depth ) +install(DIRECTORY shaders DESTINATION ${GFXRECON_INSTALL_TESTAPPDIR}/multisample-depth) add_dependencies(gfxrecon-testapps gfxrecon-testapp-multisample-depth) \ No newline at end of file diff --git a/test/test_apps/multisample-depth/app.cpp b/test/test_apps/multisample-depth/app.cpp index 8ce7de14e7..aad3fa4c35 100644 --- a/test/test_apps/multisample-depth/app.cpp +++ b/test/test_apps/multisample-depth/app.cpp @@ -20,6 +20,8 @@ ** DEALINGS IN THE SOFTWARE. */ +#define VMA_IMPLEMENTATION + #include #include @@ -29,11 +31,14 @@ #include -GFXRECON_BEGIN_NAMESPACE(gfxrecon) +namespace gfxrecon +{ -GFXRECON_BEGIN_NAMESPACE(test_app) +namespace test_app +{ -GFXRECON_BEGIN_NAMESPACE(multisample_depth) +namespace multisample_depth +{ const size_t MAX_FRAMES_IN_FLIGHT = 2; @@ -77,10 +82,17 @@ class App : public gfxrecon::test::TestAppBase void cleanup() override; bool frame(const int frame_num) override; void setup() override; - void configure_swapchain_builder(gfxrecon::test::SwapchainBuilder& swapchain_builder) override; + void configure_instance_builder(test::InstanceBuilder& instance_builder, vkmock::TestConfig*) override; + void configure_swapchain_builder(gfxrecon::test::SwapchainBuilder& swapchain_builder, vkmock::TestConfig*) override; }; -void App::configure_swapchain_builder(gfxrecon::test::SwapchainBuilder& swapchain_builder) +void App::configure_instance_builder(test::InstanceBuilder& instance_builder, vkmock::TestConfig* test_config) +{ + test_config->device_api_version_override = VK_MAKE_API_VERSION(0, 1, 3, 296); + TestAppBase::configure_instance_builder(instance_builder, test_config); +} + +void App::configure_swapchain_builder(gfxrecon::test::SwapchainBuilder& swapchain_builder, vkmock::TestConfig*) { swapchain_builder.add_image_usage_flags(VK_IMAGE_USAGE_TRANSFER_DST_BIT); } @@ -238,8 +250,8 @@ void App::create_render_pass() void App::create_graphics_pipeline() { - auto vert_module = gfxrecon::test::readShaderFromFile(init.disp, "vert.spv"); - auto frag_module = gfxrecon::test::readShaderFromFile(init.disp, "frag.spv"); + auto vert_module = gfxrecon::test::readShaderFromFile(init.disp, "shaders/vert.spv"); + auto frag_module = gfxrecon::test::readShaderFromFile(init.disp, "shaders/frag.spv"); VkPipelineShaderStageCreateInfo vert_stage_info = {}; vert_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; @@ -656,11 +668,11 @@ void App::setup() sync_ = gfxrecon::test::create_sync_objects(init.swapchain, init.disp, MAX_FRAMES_IN_FLIGHT); } -GFXRECON_END_NAMESPACE(multisample_depth) +} // namespace multisample_depth -GFXRECON_END_NAMESPACE(test_app) +} // namespace test_app -GFXRECON_END_NAMESPACE(gfxrecon) +} // namespace gfxrecon int main(int argc, char* argv[]) { @@ -670,7 +682,7 @@ int main(int argc, char* argv[]) app.run("multisample depth"); return 0; } - catch (std::exception& e) + catch (const std::exception& e) { std::cout << e.what() << std::endl; return -1; diff --git a/test/test_apps/pipeline-binaries/CMakeLists.txt b/test/test_apps/pipeline-binaries/CMakeLists.txt index 45749732fd..7ab9c4f943 100644 --- a/test/test_apps/pipeline-binaries/CMakeLists.txt +++ b/test/test_apps/pipeline-binaries/CMakeLists.txt @@ -26,51 +26,13 @@ # Description: CMake script for pipeline-binaries test app ############################################################################### -add_executable(gfxrecon-testapp-pipeline-binaries "") +add_executable(gfxrecon-testapp-pipeline-binaries app.cpp) -target_sources(gfxrecon-testapp-pipeline-binaries - PRIVATE - ${CMAKE_CURRENT_LIST_DIR}/app.cpp - ${CMAKE_CURRENT_LIST_DIR}/../common/test_app_base.cpp) - -target_include_directories(gfxrecon-testapp-pipeline-binaries PUBLIC - ${CMAKE_BINARY_DIR} - ${CMAKE_CURRENT_LIST_DIR}/../common) - -target_link_libraries(gfxrecon-testapp-pipeline-binaries - gfxrecon_application - gfxrecon_decode - gfxrecon_graphics - gfxrecon_format - gfxrecon_util - SDL3::SDL3 - platform_specific) - -if (MSVC) - # Force inclusion of "gfxrecon_disable_popup_result" variable in linking. - # On 32-bit windows, MSVC prefixes symbols with "_" but on 64-bit windows it doesn't. - if(CMAKE_SIZEOF_VOID_P EQUAL 4) - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:_gfxrecon_disable_popup_result") - else() - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:gfxrecon_disable_popup_result") - endif() -endif() +target_link_libraries(gfxrecon-testapp-pipeline-binaries gfxrecon-testapp-base) common_build_directives(gfxrecon-testapp-pipeline-binaries) -add_custom_command( - TARGET gfxrecon-testapp-pipeline-binaries - POST_BUILD - COMMAND - ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_LIST_DIR}/shaders ${CMAKE_CURRENT_BINARY_DIR} - DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}) -if (WIN32) -add_custom_command(TARGET gfxrecon-testapp-pipeline-binaries POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ - COMMAND_EXPAND_LISTS) -endif () - -install(TARGETS gfxrecon-testapp-pipeline-binaries RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) +install(TARGETS gfxrecon-testapp-pipeline-binaries RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTAPPDIR}/pipeline-binaries ) +install(DIRECTORY shaders DESTINATION ${GFXRECON_INSTALL_TESTAPPDIR}/pipeline-binaries) add_dependencies(gfxrecon-testapps gfxrecon-testapp-pipeline-binaries) \ No newline at end of file diff --git a/test/test_apps/pipeline-binaries/app.cpp b/test/test_apps/pipeline-binaries/app.cpp index 6b3dfe307b..2307fd86c9 100644 --- a/test/test_apps/pipeline-binaries/app.cpp +++ b/test/test_apps/pipeline-binaries/app.cpp @@ -29,11 +29,14 @@ #include -GFXRECON_BEGIN_NAMESPACE(gfxrecon) +namespace gfxrecon +{ -GFXRECON_BEGIN_NAMESPACE(test_app) +namespace test_app +{ -GFXRECON_BEGIN_NAMESPACE(pipeline_binaries) +namespace pipeline_binaries +{ class App : public gfxrecon::test::TestAppBase { @@ -49,23 +52,27 @@ class App : public gfxrecon::test::TestAppBase VkPipelineLayout pipeline_layout_; VkPipeline graphics_pipeline_; - void configure_instance_builder(test::InstanceBuilder& instance_builder) override; - void configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector) override; + void configure_instance_builder(test::InstanceBuilder& instance_builder, vkmock::TestConfig*) override; + void configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector, + vkmock::TestConfig*) override; void configure_device_builder(test::DeviceBuilder& device_builder, - test::PhysicalDevice const& physical_device) override; + test::PhysicalDevice const& physical_device, + vkmock::TestConfig*) override; void create_graphics_pipeline(); void cleanup() override; bool frame(const int frame_num) override; void setup() override; }; -void App::configure_instance_builder(test::InstanceBuilder& instance_builder) +void App::configure_instance_builder(test::InstanceBuilder& instance_builder, vkmock::TestConfig* test_config) { + test_config->device_api_version_override = VK_MAKE_API_VERSION(0, 1, 3, 296); + instance_builder.require_api_version(VK_API_VERSION_1_1); } -void App::configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector) +void App::configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector, vkmock::TestConfig*) { phys_device_selector.add_required_extension("VK_KHR_multiview"); phys_device_selector.add_required_extension("VK_KHR_maintenance2"); @@ -76,7 +83,9 @@ void App::configure_physical_device_selector(test::PhysicalDeviceSelector& phys_ phys_device_selector.add_required_extension("VK_KHR_pipeline_binary"); } -void App::configure_device_builder(test::DeviceBuilder& device_builder, test::PhysicalDevice const& physical_device) +void App::configure_device_builder(test::DeviceBuilder& device_builder, + test::PhysicalDevice const& physical_device, + vkmock::TestConfig*) { dynamic_rendering_features_.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; dynamic_rendering_features_.pNext = nullptr; @@ -91,8 +100,8 @@ void App::configure_device_builder(test::DeviceBuilder& device_builder, test::Ph void App::create_graphics_pipeline() { - auto vert_module = gfxrecon::test::readShaderFromFile(init.disp, "vert.spv"); - auto frag_module = gfxrecon::test::readShaderFromFile(init.disp, "frag.spv"); + auto vert_module = gfxrecon::test::readShaderFromFile(init.disp, "shaders/vert.spv"); + auto frag_module = gfxrecon::test::readShaderFromFile(init.disp, "shaders/frag.spv"); VkPipelineShaderStageCreateInfo vert_stage_info = {}; vert_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; @@ -297,11 +306,11 @@ void App::setup() create_graphics_pipeline(); } -GFXRECON_END_NAMESPACE(pipeline_binaries) +} // namespace pipeline_binaries -GFXRECON_END_NAMESPACE(test_app) +} // namespace test_app -GFXRECON_END_NAMESPACE(gfxrecon) +} // namespace gfxrecon int main(int argc, char* argv[]) { @@ -311,7 +320,7 @@ int main(int argc, char* argv[]) app.run("pipeline binaries"); return 0; } - catch (std::exception& e) + catch (const std::exception& e) { std::cout << e.what() << std::endl; return -1; diff --git a/test/test_apps/shader-objects/CMakeLists.txt b/test/test_apps/shader-objects/CMakeLists.txt index 7006310500..96e6736f34 100644 --- a/test/test_apps/shader-objects/CMakeLists.txt +++ b/test/test_apps/shader-objects/CMakeLists.txt @@ -26,51 +26,13 @@ # Description: CMake script for shader-objects test app ############################################################################### -add_executable(gfxrecon-testapp-shader-objects "") +add_executable(gfxrecon-testapp-shader-objects app.cpp) -target_sources(gfxrecon-testapp-shader-objects - PRIVATE - ${CMAKE_CURRENT_LIST_DIR}/app.cpp - ${CMAKE_CURRENT_LIST_DIR}/../common/test_app_base.cpp) - -target_include_directories(gfxrecon-testapp-shader-objects PUBLIC - ${CMAKE_BINARY_DIR} - ${CMAKE_CURRENT_LIST_DIR}/../common) - -target_link_libraries(gfxrecon-testapp-shader-objects - gfxrecon_application - gfxrecon_decode - gfxrecon_graphics - gfxrecon_format - gfxrecon_util - SDL3::SDL3 - platform_specific) - -if (MSVC) - # Force inclusion of "gfxrecon_disable_popup_result" variable in linking. - # On 32-bit windows, MSVC prefixes symbols with "_" but on 64-bit windows it doesn't. - if (CMAKE_SIZEOF_VOID_P EQUAL 4) - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:_gfxrecon_disable_popup_result") - else () - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:gfxrecon_disable_popup_result") - endif () -endif () +target_link_libraries(gfxrecon-testapp-shader-objects gfxrecon-testapp-base) common_build_directives(gfxrecon-testapp-shader-objects) -add_custom_command( - TARGET gfxrecon-testapp-shader-objects - POST_BUILD - COMMAND - ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_LIST_DIR}/shaders ${CMAKE_CURRENT_BINARY_DIR} - DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}) -if (WIN32) - add_custom_command(TARGET gfxrecon-testapp-shader-objects POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ - COMMAND_EXPAND_LISTS) -endif () - -install(TARGETS gfxrecon-testapp-shader-objects RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) +install(TARGETS gfxrecon-testapp-shader-objects RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTAPPDIR}/shader-objects) +install(DIRECTORY shaders DESTINATION ${GFXRECON_INSTALL_TESTAPPDIR}/shader-objects) add_dependencies(gfxrecon-testapps gfxrecon-testapp-shader-objects) \ No newline at end of file diff --git a/test/test_apps/shader-objects/app.cpp b/test/test_apps/shader-objects/app.cpp index dbe3ecf8c6..83f68cf934 100644 --- a/test/test_apps/shader-objects/app.cpp +++ b/test/test_apps/shader-objects/app.cpp @@ -29,11 +29,14 @@ #include -GFXRECON_BEGIN_NAMESPACE(gfxrecon) +namespace gfxrecon +{ -GFXRECON_BEGIN_NAMESPACE(test_app) +namespace test_app +{ -GFXRECON_BEGIN_NAMESPACE(shader_objects) +namespace shader_objects +{ const size_t MAX_FRAMES_IN_FLIGHT = 2; @@ -59,10 +62,14 @@ class App : public gfxrecon::test::TestAppBase VkPhysicalDeviceShaderObjectFeaturesEXT shader_object_features_; VkPhysicalDeviceFeatures2 features2_; - void configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector) override; + void configure_instance_builder(test::InstanceBuilder& instance_builder, vkmock::TestConfig*) override; + + void configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector, + vkmock::TestConfig*) override; void configure_device_builder(test::DeviceBuilder& device_builder, - test::PhysicalDevice const& physical_device) override; + test::PhysicalDevice const& physical_device, + vkmock::TestConfig*) override; void create_shader_objects(); void cleanup() override; @@ -70,7 +77,13 @@ class App : public gfxrecon::test::TestAppBase void setup() override; }; -void App::configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector) +void App::configure_instance_builder(test::InstanceBuilder& instance_builder, vkmock::TestConfig* test_config) +{ + test_config->device_api_version_override = VK_MAKE_API_VERSION(0, 1, 3, 296); + TestAppBase::configure_instance_builder(instance_builder, test_config); +} + +void App::configure_physical_device_selector(test::PhysicalDeviceSelector& phys_device_selector, vkmock::TestConfig*) { phys_device_selector.add_required_extension("VK_KHR_multiview"); phys_device_selector.add_required_extension("VK_KHR_maintenance2"); @@ -80,7 +93,9 @@ void App::configure_physical_device_selector(test::PhysicalDeviceSelector& phys_ phys_device_selector.add_required_extension("VK_EXT_shader_object"); } -void App::configure_device_builder(test::DeviceBuilder& device_builder, test::PhysicalDevice const& physical_device) +void App::configure_device_builder(test::DeviceBuilder& device_builder, + test::PhysicalDevice const& physical_device, + vkmock::TestConfig*) { dynamic_rendering_features_.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; dynamic_rendering_features_.pNext = nullptr; @@ -101,11 +116,11 @@ void App::configure_device_builder(test::DeviceBuilder& device_builder, test::Ph void App::create_shader_objects() { - auto vert_shader = gfxrecon::test::readFile("green.vspv"); - auto tesc_shader = gfxrecon::test::readFile("green.tcspv"); - auto tese_shader = gfxrecon::test::readFile("green.tespv"); - auto geom_shader = gfxrecon::test::readFile("green.gspv"); - auto frag_shader = gfxrecon::test::readFile("green.fspv"); + auto vert_shader = gfxrecon::test::readFile("shaders/green.vspv"); + auto tesc_shader = gfxrecon::test::readFile("shaders/green.tcspv"); + auto tese_shader = gfxrecon::test::readFile("shaders/green.tespv"); + auto geom_shader = gfxrecon::test::readFile("shaders/green.gspv"); + auto frag_shader = gfxrecon::test::readFile("shaders/green.fspv"); VkShaderCreateInfoEXT shader_create_infos[5]; shader_create_infos[0].sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT; @@ -461,11 +476,11 @@ void App::setup() init.disp.allocateCommandBuffers(&command_buffer_allocate_info, command_buffers_); } -GFXRECON_END_NAMESPACE(shader_objects) +} // namespace shader_objects -GFXRECON_END_NAMESPACE(test_app) +} // namespace test_app -GFXRECON_END_NAMESPACE(gfxrecon) +} // namespace gfxrecon int main(int argc, char* argv[]) { @@ -475,7 +490,7 @@ int main(int argc, char* argv[]) app.run("shader objects"); return 0; } - catch (std::exception& e) + catch (const std::exception& e) { std::cout << e.what() << std::endl; return -1; diff --git a/test/test_apps/triangle/CMakeLists.txt b/test/test_apps/triangle/CMakeLists.txt index 9d4afead26..76b0984c91 100644 --- a/test/test_apps/triangle/CMakeLists.txt +++ b/test/test_apps/triangle/CMakeLists.txt @@ -24,51 +24,13 @@ # Description: CMake script for triangle test app ############################################################################### -add_executable(gfxrecon-testapp-triangle "") +add_executable(gfxrecon-testapp-triangle app.cpp) -target_sources(gfxrecon-testapp-triangle - PRIVATE - ${CMAKE_CURRENT_LIST_DIR}/app.cpp - ${CMAKE_CURRENT_LIST_DIR}/../common/test_app_base.cpp) - -target_include_directories(gfxrecon-testapp-triangle PUBLIC - ${CMAKE_BINARY_DIR} - ${CMAKE_CURRENT_LIST_DIR}/../common) - -target_link_libraries(gfxrecon-testapp-triangle - gfxrecon_application - gfxrecon_decode - gfxrecon_graphics - gfxrecon_format - gfxrecon_util - SDL3::SDL3 - platform_specific) - -if (MSVC) - # Force inclusion of "gfxrecon_disable_popup_result" variable in linking. - # On 32-bit windows, MSVC prefixes symbols with "_" but on 64-bit windows it doesn't. - if (CMAKE_SIZEOF_VOID_P EQUAL 4) - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:_gfxrecon_disable_popup_result") - else () - target_link_options(gfxrecon-replay PUBLIC "LINKER:/Include:gfxrecon_disable_popup_result") - endif () -endif () +target_link_libraries(gfxrecon-testapp-triangle gfxrecon-testapp-base) common_build_directives(gfxrecon-testapp-triangle) -add_custom_command( - TARGET gfxrecon-testapp-triangle - POST_BUILD - COMMAND - ${CMAKE_COMMAND} -E copy_directory - ${CMAKE_CURRENT_LIST_DIR}/shaders ${CMAKE_CURRENT_BINARY_DIR} - DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}) -if (WIN32) - add_custom_command(TARGET gfxrecon-testapp-triangle POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ - COMMAND_EXPAND_LISTS) -endif () - -install(TARGETS gfxrecon-testapp-triangle RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) +install(TARGETS gfxrecon-testapp-triangle RUNTIME DESTINATION ${GFXRECON_INSTALL_TESTAPPDIR}/triangle) +install(DIRECTORY shaders DESTINATION ${GFXRECON_INSTALL_TESTAPPDIR}/triangle) add_dependencies(gfxrecon-testapps gfxrecon-testapp-triangle) \ No newline at end of file diff --git a/test/test_apps/triangle/app.cpp b/test/test_apps/triangle/app.cpp index 1f342259a4..3bf766f30f 100644 --- a/test/test_apps/triangle/app.cpp +++ b/test/test_apps/triangle/app.cpp @@ -28,11 +28,14 @@ #include -GFXRECON_BEGIN_NAMESPACE(gfxrecon) +namespace gfxrecon +{ -GFXRECON_BEGIN_NAMESPACE(test_app) +namespace test_app +{ -GFXRECON_BEGIN_NAMESPACE(triangle) +namespace triangle +{ const size_t MAX_FRAMES_IN_FLIGHT = 2; @@ -64,8 +67,17 @@ class App : public gfxrecon::test::TestAppBase void cleanup() override; bool frame(const int frame_num) override; void setup() override; + + void configure_instance_builder(gfxrecon::test::InstanceBuilder& instance_builder, vkmock::TestConfig*) override; }; +void App::configure_instance_builder(gfxrecon::test::InstanceBuilder& instance_builder, vkmock::TestConfig* test_config) +{ + test_config->device_api_version_override = VK_MAKE_API_VERSION(0, 1, 3, 296); + + TestAppBase::configure_instance_builder(instance_builder, test_config); +} + void App::create_render_pass() { VkAttachmentDescription color_attachment = {}; @@ -101,8 +113,8 @@ void App::create_render_pass() void App::create_graphics_pipeline() { - auto vert_module = gfxrecon::test::readShaderFromFile(init.disp, "vert.spv"); - auto frag_module = gfxrecon::test::readShaderFromFile(init.disp, "frag.spv"); + auto vert_module = gfxrecon::test::readShaderFromFile(init.disp, "shaders/vert.spv"); + auto frag_module = gfxrecon::test::readShaderFromFile(init.disp, "shaders/frag.spv"); VkPipelineShaderStageCreateInfo vert_stage_info = {}; vert_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; @@ -475,11 +487,11 @@ void App::setup() sync_ = gfxrecon::test::create_sync_objects(init.swapchain, init.disp, MAX_FRAMES_IN_FLIGHT); } -GFXRECON_END_NAMESPACE(triangle) +} // namespace triangle -GFXRECON_END_NAMESPACE(test_app) +} // namespace test_app -GFXRECON_END_NAMESPACE(gfxrecon) +} // namespace gfxrecon int main(int argc, char* argv[]) { @@ -489,7 +501,7 @@ int main(int argc, char* argv[]) app.run("triangle"); return 0; } - catch (std::exception& e) + catch (const std::exception& e) { std::cout << e.what() << std::endl; return -1; diff --git a/test/test_cases/multisample-depth.cpp b/test/test_cases/multisample-depth.cpp new file mode 100644 index 0000000000..e3f0658fc6 --- /dev/null +++ b/test/test_cases/multisample-depth.cpp @@ -0,0 +1,22 @@ +#include + +#include "verify-gfxr.h" + +char const* const APP_RUN_DIRECTORY = "multisample-depth"; + +#ifdef WIN32 +char const* const APP_PATH = "gfxrecon-testapp-multisample-depth.exe"; +#else +char const* const APP_PATH = "gfxrecon-testapp-multisample-depth"; +#endif + +#ifdef __APPLE__ +char const* const KNOWN_GFXR_PATH = "multisample-depth_macos.gfxr"; +#else +char const* const KNOWN_GFXR_PATH = "multisample-depth.gfxr"; +#endif + +TEST(MultisampleDepth, CorrectGFXR) +{ + verify_gfxr(APP_RUN_DIRECTORY, APP_PATH, KNOWN_GFXR_PATH); +} diff --git a/test/test_cases/pipeline-binaries.cpp b/test/test_cases/pipeline-binaries.cpp new file mode 100644 index 0000000000..7a9f777737 --- /dev/null +++ b/test/test_cases/pipeline-binaries.cpp @@ -0,0 +1,22 @@ +#include + +#include "verify-gfxr.h" + +char const* const APP_RUN_DIRECTORY = "pipeline-binaries"; + +#ifdef WIN32 +char const* const APP_PATH = "gfxrecon-testapp-pipeline-binaries.exe"; +#else +char const* const APP_PATH = "gfxrecon-testapp-pipeline-binaries"; +#endif + +#ifdef __APPLE__ +char const* const KNOWN_GFXR_PATH = "pipeline-binaries_macos.gfxr"; +#else +char const* const KNOWN_GFXR_PATH = "pipeline-binaries.gfxr"; +#endif + +TEST(PipelineBinaries, CorrectGFXR) +{ + verify_gfxr(APP_RUN_DIRECTORY, APP_PATH, KNOWN_GFXR_PATH); +} diff --git a/test/test_cases/shader-objects.cpp b/test/test_cases/shader-objects.cpp new file mode 100644 index 0000000000..a41013b98a --- /dev/null +++ b/test/test_cases/shader-objects.cpp @@ -0,0 +1,22 @@ +#include + +#include "verify-gfxr.h" + +char const* const APP_RUN_DIRECTORY = "shader-objects"; + +#ifdef WIN32 +char const* const APP_PATH = "gfxrecon-testapp-shader-objects.exe"; +#else +char const* const APP_PATH = "gfxrecon-testapp-shader-objects"; +#endif + +#ifdef __APPLE__ +char const* const KNOWN_GFXR_PATH = "shader-objects_macos.gfxr"; +#else +char const* const KNOWN_GFXR_PATH = "shader-objects.gfxr"; +#endif + +TEST(ShaderObjects, CorrectGFXR) +{ + verify_gfxr(APP_RUN_DIRECTORY, APP_PATH, KNOWN_GFXR_PATH); +} diff --git a/test/test_cases/triangle.cpp b/test/test_cases/triangle.cpp new file mode 100644 index 0000000000..5ce41885ca --- /dev/null +++ b/test/test_cases/triangle.cpp @@ -0,0 +1,22 @@ +#include + +#include "verify-gfxr.h" + +char const* const APP_RUN_DIRECTORY = "triangle"; + +#ifdef WIN32 +char const* const APP_PATH = "gfxrecon-testapp-triangle.exe"; +#else +char const* const APP_PATH = "gfxrecon-testapp-triangle"; +#endif + +#ifdef __APPLE__ +char const* const KNOWN_GFXR_PATH = "triangle_macos.gfxr"; +#else +char const* const KNOWN_GFXR_PATH = "triangle.gfxr"; +#endif + +TEST(Triangle, CorrectGFXR) +{ + verify_gfxr(APP_RUN_DIRECTORY, APP_PATH, KNOWN_GFXR_PATH); +} diff --git a/test/verify-gfxr.cpp b/test/verify-gfxr.cpp new file mode 100644 index 0000000000..a89765d25a --- /dev/null +++ b/test/verify-gfxr.cpp @@ -0,0 +1,130 @@ +#include "verify-gfxr.h" + +#include +#include +#include +#include +#include + +bool clean_gfxr_json(int depth, nlohmann::json::parse_event_t event, nlohmann::json& parsed) +{ + switch (event) + { + case nlohmann::json::parse_event_t::key: + { + auto key = to_string(parsed); + if (std::strncmp("\"pfn\"", key.c_str(), 4) == 0) + return false; + if (key == "\"hinstance\"") + return false; + if (key == "\"hwnd\"") + return false; + if (key == "\"pipelineCacheUUID\"") + return false; + } + break; + case nlohmann::json::parse_event_t::object_end: + if (depth == 1 && parsed.contains("header")) + return false; + if (depth == 1 && parsed.contains("annotation")) + return false; + if (depth == 1 && parsed.contains("meta")) + return false; + break; + } + + return true; +} + +#if defined(__linux__) || defined(__APPLE__) +static char const* CONVERT_FILENAME = "gfxrecon-convert"; +#elif defined(_WIN32) +static char const* CONVERT_FILENAME = "gfxrecon-convert.exe"; +#endif + +struct Paths +{ + std::filesystem::path base_path{ std::filesystem::current_path() }; + std::filesystem::path full_app_directory{ base_path }; + std::filesystem::path full_executable_path; + std::filesystem::path convert_path{ base_path }; + std::filesystem::path capture_path{ base_path }; + std::filesystem::path known_good_path{ base_path }; + std::filesystem::path app_json_path; + std::filesystem::path known_good_json_path; + + Paths(char const* app_directory, char const* app_executable, char const* known_gfxr_path) + { + full_app_directory.append("test_apps"); + full_app_directory.append(app_directory); + + full_executable_path = std::filesystem::path{ full_app_directory }; + full_executable_path.append(app_executable); + + convert_path.append(CONVERT_FILENAME); + + capture_path.append("test_apps"); + capture_path.append(app_directory); + capture_path.append("actual.gfxr"); + + known_good_path.append("known_good"); + known_good_path.append(known_gfxr_path); + + app_json_path = std::filesystem::path{ capture_path }; + app_json_path.replace_extension(".json"); + + known_good_json_path = std::filesystem::path{ known_good_path }; + known_good_json_path.replace_extension(".json"); + } +}; + +int run_command(std::filesystem::path const& working_directory, + std::filesystem::path const& command, + std::vector args) +{ + std::string command_string; + command_string += command.string(); + for (auto& arg : args) + { + command_string += " "; + command_string += arg; + } + + auto previous_path = std::filesystem::current_path(); + std::filesystem::current_path(working_directory); + auto result = std::system(command_string.c_str()); + std::filesystem::current_path(previous_path); + return result; +} + +void verify_gfxr(char const* app_directory, char const* app_executable, char const* known_gfxr_path) +{ + Paths paths{ app_directory, app_executable, known_gfxr_path }; + + int result; + + // run app + result = run_command(paths.full_app_directory, paths.full_executable_path, {}); + ASSERT_EQ(result, 0) << "command failed " << paths.full_executable_path << " in path " << paths.full_app_directory; + + // convert actual gfxr + result = run_command(paths.base_path, paths.convert_path, { paths.capture_path.string() }); + ASSERT_EQ(result, 0) << "command failed " << paths.convert_path << " " << paths.capture_path << " in path " + << paths.base_path; + + // convert known good gfxr + result = run_command(paths.base_path, paths.convert_path, { paths.known_good_path.string() }); + ASSERT_EQ(result, 0) << "command failed " << paths.convert_path << " " << paths.known_good_path << " in path " + << paths.base_path; + + std::ifstream app_file{ paths.app_json_path }; + ASSERT_TRUE(app_file.is_open()) << "app json file would not open"; + auto app_json = nlohmann::json::parse(app_file, clean_gfxr_json); + + std::ifstream known_file{ paths.known_good_json_path }; + ASSERT_TRUE(known_file.is_open()) << "known good json file would not open"; + auto known_json = nlohmann::json::parse(known_file, clean_gfxr_json); + + auto diff = nlohmann::json::diff(known_json, app_json); + ASSERT_EQ(diff.size(), 0) << std::setw(4) << diff; +} \ No newline at end of file diff --git a/test/verify-gfxr.h b/test/verify-gfxr.h new file mode 100644 index 0000000000..42e0b133b6 --- /dev/null +++ b/test/verify-gfxr.h @@ -0,0 +1,22 @@ +#ifndef GFXRECONSTRUCT_VERIFY_GFXR_H +#define GFXRECONSTRUCT_VERIFY_GFXR_H + +/* + * Run an application with capture enabled, and compare the resulting gfxr file to a known good gfxr + * + * app_run_directory - the directory to run the application from, relative to test_apps folder + * app_path - the path to the application, relative to app_run_directory + * known_gfxr_path - path to the known good gfxr file, relative to the known_good folder + * + * expects the following environment variables to be set + * VK_LAYER_PATH - path to VkLayer_gfxreconstruct.dll + * VK_DRIVER_FILES - path to VkICD_mock_icd.json + * + * expects the following environment variables to be set with the following values + * VK_INSTANCE_LAYERS=VK_LAYER_LUNARG_gfxreconstruct + * GFXRECON_CAPTURE_FILE_TIMESTAMP=false + * GFXRECON_CAPTURE_FILE=actual.gfxr + */ +void verify_gfxr(char const* app_directory, char const* app_executable, char const* known_gfxr_path); + +#endif // GFXRECONSTRUCT_VERIFY_GFXR_H From e8412cf5e091bd2654cdf158c4354932c905d7e0 Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Mon, 27 Jan 2025 11:44:03 -0500 Subject: [PATCH 02/12] Add instructions for running tests --- TESTING_test_apps.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/TESTING_test_apps.md b/TESTING_test_apps.md index d37ac4141e..390998dbcc 100644 --- a/TESTING_test_apps.md +++ b/TESTING_test_apps.md @@ -36,3 +36,14 @@ Use of the *TestAppBase* is optional. Test apps are built as part of the default build CMAKE build process. In order to stop test apps from building, set the **GFXRECON_INCLUDE_TEST_APPS** CMake variable to OFF, e.g. provide `-DGFXRECON_INCLUDE_TEST_APPS=OFF` in your cmake command line. + +## **Test App Verification** + +To run the test apps and validate output against known good '.gfxr' files, build the project using ./scripts/build.py, +and then run the test script from within the 'test' install directory. + +|Operating System|Test Directory|Test Script| +|---------------|---------------|------------| +|Windows|build/windows/x64/output/test|run-tests.ps1| +|Linux|build/linux/x64/output/test|run-tests.sh| +|MacOs|build/darwin/universal/output/test|run-tests_macos.sh| From 130dd3ad8602852a3373c252d93930695bc394e0 Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Thu, 30 Jan 2025 16:36:42 -0500 Subject: [PATCH 03/12] Fix post rebase --- test/CMakeLists.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 2100c8bffe..f8eae2546c 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -26,7 +26,6 @@ cmake_minimum_required(VERSION 3.24.0) -add_subdirectory(test_apps) if (NOT DEFINED ENV{GFXRECON_NO_TEST_APPS}) set(GFXRECON_INSTALL_TESTDIR ${CMAKE_INSTALL_PREFIX}/test) From 9fed44fd500334d52e8fe3ee2008e7f00e4b4f3d Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Tue, 18 Feb 2025 13:35:58 -0500 Subject: [PATCH 04/12] Clarify test app verification instructions --- TESTING_test_apps.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/TESTING_test_apps.md b/TESTING_test_apps.md index 390998dbcc..5709e89000 100644 --- a/TESTING_test_apps.md +++ b/TESTING_test_apps.md @@ -39,11 +39,11 @@ Test apps are built as part of the default build CMAKE build process. In order t ## **Test App Verification** -To run the test apps and validate output against known good '.gfxr' files, build the project using ./scripts/build.py, -and then run the test script from within the 'test' install directory. - -|Operating System|Test Directory|Test Script| -|---------------|---------------|------------| -|Windows|build/windows/x64/output/test|run-tests.ps1| -|Linux|build/linux/x64/output/test|run-tests.sh| -|MacOs|build/darwin/universal/output/test|run-tests_macos.sh| +To run the test apps and validate output against known good '.gfxr' files, build the project and then run the test script from within the 'test' install directory. + + +|Operating System| ./scripts/build.py Test Directory |Test Script| +|---------------|------------------------------------|------------| +|Windows| build/windows/x64/output/test |run-tests.ps1| +|Linux| build/linux/x64/output/test |run-tests.sh| +|MacOs| build/darwin/universal/output/test |run-tests_macos.sh| From 92e9a9ebb4687fd2046afd0915da00232c57824e Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Tue, 18 Feb 2025 14:47:31 -0500 Subject: [PATCH 05/12] Remove old mock icd readme --- test/icd/README.md | 80 ---------------------------------------------- 1 file changed, 80 deletions(-) delete mode 100644 test/icd/README.md diff --git a/test/icd/README.md b/test/icd/README.md deleted file mode 100644 index 1c6e6eae19..0000000000 --- a/test/icd/README.md +++ /dev/null @@ -1,80 +0,0 @@ -# Vulkan Mock ICD - -This directory contains a mock ICD driver designed for validation layer testing. - -## Introduction - -The mock ICD is focused on enabling validation testing apart from an actual device. Because the validation layers -sit on top of the ICD and don't depend upon the results of Vulkan rendering, they can be tested without having actual -GPU hardware backing the ICD. The final mock driver will be composed of three main features: a null driver, flexible -device configuration, and entrypoint tracking & verification. - -### Null Driver -The intial mock driver features just the null driver capability. This allows all of the validation tests to be run -on a fixed device configuration that is hard-coded into the ICD. - -### Entrypoint Tracking & Verification -Entrypoint tracking and verification will be added to the mock layer as a later feature. The idea is that all expected -Vulkan function calls and their parameters can be stored in the ICD and then a separate call can be made to verify that -the exepected calls and parameters actually entered the ICD. This allows verification that the validation layers are -correctly passing calls and their parameters through to the ICD unchanged. - -## Using the Mock ICD - -To enable the mock ICD, set VK\_ICD\_FILENAMES environment variable to point to your {BUILD_DIR}/icd/VkICD\_mock\_icd.json. - -## Plans - -The initial mock ICD is just the null driver which can be used to test validation layers on -simulated devices. Here's a rough sequence of tasks planned for the mock driver going forward: -- [X] Get all LVL tests passing on the bare null driver -- [X] Get failing tests passing -- [X] Get skipped tests passing as able -- [ ] Get all LVL tests to run without unexpected errors -- [X] Develop automated test flow using mock ICD (alternative to or replacement for run\_all\_tests.sh) -- [ ] Update LVL tests with device dependencies to target specific device profiles -- [ ] Add entrypoint tracking & verification -- [ ] Initially track expected calls -- [ ] Update some tests to verify expected capability -- [ ] Expand tracking to include parameters - -## Beyond Validation Layer Testing - -The focus of the mock icd is for validation testing, but the code is available to use and enhance for anyone wishing to apply it for alternative -purposes. -With the following enhancements, the mock driver state available to the app should very closely mimic an actual ICD: -- Update various function return codes -- Simulated synchronization objects -- Simulated query with mock data -- Basic command buffer state tracking to note synch object transitions and query state updates - -Beyond that it's certainly possible that the mock icd could be hooked up to a SW renderer and serve as a virtual GPU with complete rendering/compute -capabilities. - -## Status - -This is a temporary section used for tracking as the mock icd is being developed. Once all tests are passing with the mock, this section can be removed. -Currently 333/333 tests are passing with the mock icd, but many passing tests have unexpected validation errors that need to be cleaned up. - -### Failing Tests - -NONE - -### Passing Tests With Unexpected Errors - -- VkLayerTest.RenderPassInUseDestroyedSignaled -- VkLayerTest.RenderPassIncompatible - -### Skipped Tests - -- VkLayerTest.BindImageInvalidMemoryType -- VkLayerTest.CreatePipelineBadVertexAttributeFormat -- VkLayerTest.MiscBlitImageTests -- VkLayerTest.TemporaryExternalSemaphore -- VkLayerTest.TemporaryExternalFence -- VkLayerTest.InvalidBarriers -- VkLayerTest.CommandQueueFlags -- VkPositiveLayerTest.TwoQueuesEnsureCorrectRetirementWithWorkStolen -- VkPositiveLayerTest.ExternalSemaphore -- VkPositiveLayerTest.ExternalFence -- VkPositiveLayerTest.ExternalMemory From a78026b2558ed5dd65d7801e8f2b109c2da78909 Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Tue, 18 Feb 2025 14:56:57 -0500 Subject: [PATCH 06/12] Add back portability enumeration support --- test/test_apps/common/test_app_base.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/test/test_apps/common/test_app_base.cpp b/test/test_apps/common/test_app_base.cpp index 007e7d2b24..532f9884b8 100644 --- a/test/test_apps/common/test_app_base.cpp +++ b/test/test_apps/common/test_app_base.cpp @@ -830,6 +830,16 @@ Instance InstanceBuilder::build() const extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); } +#if defined(VK_KHR_portability_enumeration) + bool portability_enumeration_support = detail::check_extension_supported(system.available_extensions, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); + if (portability_enumeration_support) + { + extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); + } +#else + bool portability_enumeration_support = false; +#endif + if (!info.headless_context) { auto check_add_window_ext = [&](const char* name) -> bool { From 06e12f0684d65325614455a35cf336460788a403 Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Tue, 18 Feb 2025 17:20:58 -0500 Subject: [PATCH 07/12] Try to remove admin path in run tests powershell --- test/run-tests.ps1 | 21 ++++----------------- 1 file changed, 4 insertions(+), 17 deletions(-) diff --git a/test/run-tests.ps1 b/test/run-tests.ps1 index 8890b92f36..c1309e73f5 100644 --- a/test/run-tests.ps1 +++ b/test/run-tests.ps1 @@ -1,20 +1,7 @@ -$is_admin = ([Security.Principal.WindowsPrincipal] ` - [Security.Principal.WindowsIdentity]::GetCurrent() ` - ).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator); - -if ($is_admin) { - New-Item -Path "HKLM:\SOFTWARE\Khronos" - New-Item -Path "HKLM:\SOFTWARE\Khronos\Vulkan" - New-Item -Path "HKLM:\SOFTWARE\Khronos\Vulkan\ImplicitLayers" - New-ItemProperty -Path "HKLM:\SOFTWARE\Khronos\Vulkan\ImplicitLayers" -Name "$pwd\VkLayer_gfxreconstruct.json" -PropertyType "DWord" -Value 0 - New-Item -Path "HKLM:\SOFTWARE\Khronos\Vulkan\Drivers" - New-ItemProperty -Path "HKLM:\SOFTWARE\Khronos\Vulkan\Drivers" -Name "$pwd\test_apps\VkICD_mock_icd.json" -PropertyType "DWord" -Value 0 -} else { - $env:VK_LAYER_PATH="$pwd" - $env:VK_IMPLICIT_LAYER_PATH="" - $env:VK_DRIVER_FILES="$pwd\test_apps\VkICD_mock_icd.json" - $env:VK_INSTANCE_LAYERS="VK_LAYER_LUNARG_gfxreconstruct" -} +$env:VK_LAYER_PATH="$pwd" +$env:VK_IMPLICIT_LAYER_PATH="" +$env:VK_DRIVER_FILES="$pwd\test_apps\VkICD_mock_icd.json" +$env:VK_INSTANCE_LAYERS="VK_LAYER_LUNARG_gfxreconstruct" $env:VK_LOADER_LAYERS_DISABLE="~all~" $env:VK_LOADER_LAYERS_ENABLE="*gfxreconstruct*" $env:GFXRECON_CAPTURE_FILE_TIMESTAMP="false" From 3e81f81930802005a2c696493cccbb15c111a7ab Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Tue, 18 Feb 2025 18:14:33 -0500 Subject: [PATCH 08/12] Less debugging, updated known good --- test/known_good/multisample-depth.gfxr | Bin 28209 -> 28260 bytes test/known_good/pipeline-binaries.gfxr | Bin 8967 -> 9002 bytes test/known_good/shader-objects.gfxr | Bin 56184 -> 56263 bytes test/known_good/triangle.gfxr | Bin 25906 -> 26029 bytes test/run-tests.ps1 | 4 ++-- test/run-tests.sh | 7 ++++--- test/run-tests_macos.sh | 7 ++++--- 7 files changed, 10 insertions(+), 8 deletions(-) diff --git a/test/known_good/multisample-depth.gfxr b/test/known_good/multisample-depth.gfxr index 3dfc3c94215d674fd45f88944527098101b77465..3100b2fc67ee45c843d41891182e278d885bfef4 100644 GIT binary patch literal 28260 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 literal 28209 zcmeHQeQ;FQbwBUz+tmsLdb>{`*%Gi?EkXtfuVArdAYlR7;2J05qc&q>>vN5i2(*@j zLlU>yr1&G9bjs9jhqi8pX41xWNJhzcI>fQ@nrJ$VCvDZ((|R(QDOL1`o4T%Iw+%CP zhyKoe_pYwiTJNp|Ldodh)qC&0d(J)g+;e{S-22|H_uO^(07)`%RG%8ZTj;?dh*B96aB+|L!HNx{fVZYL~^)yW8!2Yn``lU(E^JW zShT>R1%BNv@Q<{X_NSJYP?N`Un~IG+A-a-UIDN6T|Jv-p>#9 zb$9lo>SKM~iT30m5A|?gVrbJ=a>lljz5I4EJBYSYa_Ge1Bc0ueFnUt)6$(_sl1GTX zLZ^BYojtJG&;}x}(RC5+KmF9b20dh?a4P6Qd1QNS2u#`QkSq^#(R(HvZSse%(S)HY zse_0uRYPsUPysSws1S)({1;-B#$|@~$}?`JOKWDkEEmn3=2pgDK`Z4H|Nhsv)%gkb zCBG~4(rY!8Wjg91?g?MtC!!^E??CrwL#<-y zdt@!!8L1QV}Vr0ia0Tw z%BpDfp(<(zFGp~4e_ZH5?!`WK1xA9?%U*t*}sLrwyKC=#vieSIR4Rx6drx$ zL!wOvMzH?sRoMJ2QG}}BgmhHKbwANQvMdT*g}Lq`dYD3~o#zSMVY<*m0kfJs|3pE% zhHB7ElIZW~%GEnDy>tk#fVw7?`KkHJ)vJ{TdW_!LJ5H0)#L^#t%r9{(Au2;JVSpL~ zm(VP=`{sbC@+l1MJf#dC+PJl~{6oqvR55 zq&(XAPRerONdG#HtIIFBE@)WvBiA>+pz-=O-mmGrzw$Bjl?yI2ht32(AEFn~2-ZVS zmw4IQQ(@#Mrxv3lM$|F)!iMR?+;3R!O`0*o6Uto)Vf|LKjgtB_R&li%4YlL;MGnEd%2!C?n&&vX97MYos@3 zLeg&ZlCV8TxguT1zbQgTwzgLa(RI{iw8{IqbYvN$_;hS>b+k-6$e3WZQ2NXlpWF7Q z_^^mK`45O~uvF8rj12`6^4}Q8SzKWm5`xfoY&vjqOa*pS-Ms6w!jZXJ8F5i>#yS&g(Y`2_BCkh2UC@Z-m6X&a3( z2DMc@gj@scO*9EjIZNO?VCZw5$?o3HzT;@XqJtN4r|KOet!#%&z>G`aD#Xn$y*Ay= z4r=V*(#)fVC1d`d6Wi#dj2EMV9L5xc3&R(%rz?fqS5cnkY3C|FOuB~@;>DJf&$d;b zrc~h`>N0Y9u`Xi*a^lfz>%~gG?!~$pKh}#e?ei$=GDfTDz^xze#38USdGJ{V*kGSy z;%h-%APWa%5u57;ZA4GW@~{^*-Gnans_P7I|NWnBtE(i;UVb{rrf)0*xB*as$Q8i~ zk%aAI;PYFAI0HnxN#1Kclx8a^(ntH8*0h2=(R9$4!7N+0&zdWrMmvI7eO*RemS<#0 z%+h6yqE7PnrqVOc;uRIETS^O*+3KdtVBJQv)NwAlb)=_)c(%IfGFZ3h6EoYbM;g$= zc-*0lX;PMJ?ldOVVgL~CR04P6v4uPN;Wkw~tNQ(%^h}m=6vRcFZb~G@(NCotb9;Fb zyU>5U{crc9dalGSmM5`$XW=Gxk^h`2v5Q62tkRz|v2!}&)AG9B>y_7qt#=y@cfOlS z@5%~H?}|v#4!`S;G6T&7K1VR;C}+x_qILY&;oK>jzR(G1z6~=ATF+4FE_9+2s(9;# zsmN(p<(bmCr!BFHY5dfQpv&xY;y==?N(`G zBeFcBT^%hIs~Pkb)GKc@TON$-kS5Jw+>#kEuJtNN!?`grCyAx3Y>8;D!}xfPVT7f# zhH*>|BkxctDr^{+;o6%=4J&^F|n zwC3>$S&j$i2#O90pMAB18L;4R)?x~5pf$+`$O42%c;!%eGDOtFjMjuGdW-Cf?@;iA zq?<~ks-P4EGU1Tgrs;k}W?-7`BXUV>qdIioM3%3V#z%40vF8xhFGOEP?El1L)*+e< zD87ttbCA_x3y;=N^HTEpDZOXk!F?NthI=-~wnXbFx}31qG-{~1oUkt;lsSfl$ugQO z2}3ZOiTC3?_{WyIXhdi-P)d9DweLKzt9>Yu?8G*8qJ5~hvnMgwKG5}G27dJKEpgmKeMb+oy?>W90ZmCW2w} z><0Ats00JmXc$$L>^nYuuV3${@VFmAyPIBel1 zPn>sO=rs0rj7_Ng2Nb>gc+Ve+ec&TT+arUWM|ZzWozQ77dB4V^Y%ldv36S@!*h%n{ z1!p)T&QFnra`Xs)Ta4yC4f!cQsGe+^1F#G3B zYBTm%k_GXGSwn#p7x;iCoehBC(x{06s_~ftig6RoA+jDPigQZgY=dO9frfGICwtkw zR05vm%hA%SjpW@&PI-iDTHtN)w4y&dBIE?Nd$=R2&Xf{I5s?*q_HYi2(tU=fxY%uAR;jBS}&~LTnVb#HD5j|%(wdW0b z$Dp@_9-~N0#pTl$*ElR@1av?0HaE1{qP6=hZZR%uUoqY8ISo$}wPHZY*_b54;6l|u zwm7h(hOB$mWSaseHiI`r&9{;FoJs%9gM#RfU%|1}+x$uLL@dHyEXMvh17q)e;ze@S zy=67;B=582+;Ym~=F!cwkisSp?7!f_ehf?w32gsHoL#2oHY&M9fu{2&2Htwv;F;|m za&B!iC}yyiLBpunMvNJin{fRO1!9*CWB@Gu3OQSF22HV%XVatqN6>|g2H*V`38vld zOW`2sW~k2uTTa8G^RoQou&BcXdm=wMNtvFIk+&*@p&DGGS1$S&zcUp@2`g)SP6*A0w-0Tu%HIR*poSxOC@7~ak3 zGa@{7gjyK_R)`>OAbWK!c`ybMvTSNb1dmam_NTzzGHT-x_VpN@=mBE*iWsYq5eU72 z+glBcxd>8tS)9kvS%PtdB%Cen;k!8F>r?DO%^S$-NA!N3_NR8h~kZ zpE!a&s53_Me)1yb%9S5c3wEz~I%1y+;4E#hPrZcz7tO+l>1kqzg+J9~T;!A~_NFG! znAAuqlBAx9V1!bw_SCM$K6zjB693C?mbV(WFk@jy)ryGevg;yB8a`;GG(Q_r^e5~Z zAeOvSliVsdL`35L23MNEXOe}(Ho!+jH`SHWZXC=Ag;TFYgw;%{4B~7r+4c(hCG+v7 zT>lS_h)p>wh-sYI!`jFnV@unCRa73MvV-HO)^e6AonaPluf>GmXUq;i{ljlkWkmx# zG0dZk5qEm`QRPask_MU?;lmf=-1HI?TI{x%8weO;;cJpnOl-9jG?IAg_$*acCdKj@ zL3}GM7xhNSIX^;`RS*&5OvDekgD0Ft<(r}eZLzbCZObhfcIR@1N!v}jY@i+u8@$UO zF`U$CZXI=&J;SN&C_d<#6*qZb^l@^|R2h}kZv*}q$+|k^#s!N=;Xf1V0$adtFl(IF zM?XL&cGAR6mpC6_LeEm$wGo1&2@+$U4#=xI91G*HH4c3d*`~E|Qq~b|*yAOXmW#Kw zxKU?g%E!9L$NO;Th3NX&g^2V6yUZ)@FZa$dB1*{(3)KtMpu71GhT8CS%mm}~+1Q%JG5d_&&X9E!OGUSi z)dE&*tBPlK8M(S;i&i%cpP@_A2q8)-sn@^;d!-Gkl}sG3g$*uA8!+-IV$Wt`+pg1W z+u|0xi}-Pd!BKqDa&sEdV&CM&Gi#gDyxd}9hEMVz5KH@xCT*Hq@vd(jo)3^yDb`N* z#Zu%iGA>%0Oy~NvaFe~VHOy+lO;%L% zJoAj|ravMfAiYWn$5EMt<}Q9)-Y|5k7DQ(C@nk(XHRrWV|TL zT^U9RQWh^S-h*qg((=lEjgZT*QKi12@bkxOck%9zKRqxrunpSGq>bYl`IdsI;K}}a3EG4xg#s?5v zr(Khw%BRb?DDal61N8bc_LgPQnLP5eZ?}^b%O8fE_4;!|;8ixu$Ka&pvrQ3wD zS}6D$`Xy{tIa)!s6`*Be#>D)aY9U{Q)}?lAfU%gu;;*ayLt5(@G@oR_?(Wl;e6^`45N{ zT&vY-bc=I?MH;V4WN28Pv6P@D<(w=Jm!g{)Z%cBhiVhxR)euh)j^fx7BD-=ed1|P- z0lt4oDAhvMcy}SN>NfI)s5*)&Rjb@b)q49~TKnJC+DBLj679dgd>j`lTljZ=Du!zX z5K&l5=ww%61&_AkAuM=TlewL$dD&=Ayi{LDFz7bq0$If3If@`Rg z2C8M~S|K=g2sjg&hT*sXhTE&RP|0C|;eqPabXjcIW!mqOXB@|KM)2xl5gZx|Dh@8^ zFLf?XFCE5bnpp~i@#~(5uaQRQLtYqPgD9ITj0+hH4#rulxx)A~8MA? z<6OIN7*|e~7sgrae8ad>jw7Hr7}ua@eiQLE3po+z)frQ9aH&m+_DpcOn26^}#6!Z` z?w`B}9zuZ46~Tp!1&83Q)m#yLnv7W>IP>2)1n1TZM{urPID#uD%ZuPFcD@l@DaSET z9D-}8GvA4LXyGQ}NdE;Dhv3?5IOD#>wcEokPOo2+M7&lSoez0oycSV5R~Q#E795PT zR&#~%X)(iXPP;8#KY3we8`L7`0me~5nRYva0t#?%@x6?$(RL#Gyjc4aBjVD z1n1g?Be-(1ya>)>=NrM5avTB0A-IM*^PPx?7j7c%V?%;=xd$rjnWi=y{-!75`gcOF z(W@zVvoIyi%`b5aV!O}yT$6vxg!Awh<(m`yW=a)arjmS5$|LjZFCM%o%fo`d5Cm`K zw^HI{UiUXr#ILjPv-AmkX8AmGnv9R4w+>x1zLCQG?r+HGZ=_UFa6Vp0;l>LGZ&%eq zUr14Yk(A?~?H6Zcc^!+*3En&Tg%rFXTe6(rWV%-GqbS{2h2pSV!<%W@_hYg*+{^3n zJ_^5_f|r;V>>DX1vj4@Qw>A?l=HKHmVZr%#MB1AVdGl}l64adYZy}=)^q$vu3R$bU z=HJs~d=$a+zEjBjH!lC?)(eMlu3dQkt(;7s#Pq2>1K}(-Cxo|MpLYtCavTB0VYr4m z^PPW37HIDaSd#=jZPO3f9;r^%QFiZlO>Lve1sa1`g-g`>FgvAl^mi!Btzu|BhMz8D_o zT(zJV!Pv=f^St<7 zkNC=i-+8~%@N7jhWdtU zHb-u))XxhP&T+HsRW?U%t<<;1vN`U{*$?&87lm`E-?hl**q^fvH9FZGTXS+O&(ZVS zb8@Jk*ekpZ^-bYyj@)gigd>|{cTTO;H`uc|?##)derqS2<6uq>{t+3bY>t&VIaI`D zbL1Wmwd0x1@$H;#_*|ugRw^Djvdc6M71`NR|4OT)d?#!G>eC)gsvg;m+W*&LI)|xo P=z17h8~j|GiS_t@{wt1c diff --git a/test/known_good/pipeline-binaries.gfxr b/test/known_good/pipeline-binaries.gfxr index 598dbedeacfa5febab7efea72c7f47269aaade49..c1e499e9e8f22dd7a6d1b2ea965132f25cb8d44c 100644 GIT binary patch delta 1808 zcmZWpZERCj7=G?;Z`W^iHRl#p>a{hg07DJAUfj$F)scv1o#0l(J?;4j~RT=?JyWma_)KW z`#$G6?|DDY+grcbn*G3B5~-<;wno-8)J7U2YuTsfjRke}$u;Y`qwJ>nh;W_lD|8Ke z1n6VIaE;d4cP4KAPAgYd@vj^H%%mF-xj6a*so&i4;`#f-c9=w1-H>V_Yb&r|C?S)9 z<_yi;$FGjfh_b$GJ^Tk_t&l5hn75Pdx#o`M?JXVYzW%{PXYbyfy@Q83lBuD6$^OJ( zZ(k|`<)a8}rC~@Bqz8ujUrux-{ZKCXA-jAK{g~d;*4ojNOmy!}4h%d2{EE&g;+;GC z2RR_HnxZuxHAlCwLi_4OW0e_UvYPWC_cVL0s9rLkB|AG`6m{ql*&R4FO^bGS|Jcl! zRBRTcOQ$);ZdvQlr99>aEov||HpBKO z6<|MGe8MFA%MvM&jh|r~z*d%Yx*WMhAROl8|voKrJ(r2Cd8Qo<=;=1Y|aO;agf1h{9L}zn%cd)Ca zHDYXvS*_1X55DBEc58z)dxlHLtqnF^qWg1jh9{2Qv^FoGga?ZB4nT%KeO88cFng?#8%ZLzCAnHWrV z^e0o@$^LX=V4#NTzPyHAu~h|+Kz7%_^b!WT52X_Odb`>Y?oGWCf--Ux)+`F-wX2|{ zcQe)QUGCn+yJLkgGH@V~?&_fE(Z1c<;!08_cO}o)Dx|Aoj$??22%gchDaI7=8 zUF-%z$gl%tQ7NvgW6q{BT_P6V`8>^;1!@Jhw`{XCdy#MD7+rb{ll>Qyom#?F>(XPG z@EzjGzXdt&{-cp*oe(o1LR780y=`8iXbk=ZKhr8zx~J1e~Q z`Na@WbbB4WMQPVoY!>yO;DKF`-(RAnB(5?;fhEZ}dV)yQS(pXi^AFT{!np$B8 zI{Eq8NxF!>RbC;XK!hR=!XKLovcD@-!=Cf^ndrS;LCA(` z7>FPMCAtHOllqm|b3mKm4_>^%$%{m)`prgeP%}*`^$~m;y~L=5T}YFEae=5|!K1;}sqaZ?y()iHJ>vWnyQyyYuVP!} O21($>-ll%7o delta 1841 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 BvjYGC literal 56184 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 Y8=KUcsU>u&giMDf)xoO|oS2UP13$mBhyVZp diff --git a/test/known_good/triangle.gfxr b/test/known_good/triangle.gfxr index d68bf7a37b7d185a9d72a213002cbed8f086997f..79ef56558b0162c52e52283a6eca85a23135f895 100644 GIT binary patch literal 26029 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 X+GzZ5(UUoBgTu7LGIRvvP3-tTpXQZH literal 25906 zcmeHPeQaD+cK^LMZ|rgGByaqjc)%tekDXu=C)kMt#tECr2P6p7bv~9_OTeE)V%D(- z+hMc2P^ML?O{J|GEmTcgw2HRdZoAF0rm9+mD9jqGLMy6Tuv$eGQjy746rsw%w#^@D z)8D!8J^R|7!84gKN@efTv29O8HH? z>4BvlIQICdvBbdW$mWT}_(Weaxp`u2sBh%haAHg1RAOo6oA)<8aMJ@fJ#f=b9=fHnFTZR&PybVsO zP5HhJ&-{!$eP21+jMWhYTYz{FpIBJQQtHH8JmL?$_up-Xtr&J9hTbEvE5n#8;j@Py z?76S|NY7xR|KzcrlM_S3;~U^aHXyvA5yl40RXup%P|vZ%L{IYgH^zqs`i5EcsiA>H zPjXDUdSWOszO@5RyaV>CyJ7YM9Y~I!9DBTPAQ6L;j3Hc2M;--!3#X4K`UdH;@l8O` z=%1qci@)=bfk%xLFBLuFoyA?7!VB&?;+4mw=o3?X7Jtq4netOLdI51%Xx>pK9TkPr z(w%NYnz!?Gz`GJP{hFGcUb#|pREOnmY~L}Z#; zPe;89N@jYBccGuSmRBJqLrBPvyQR$S?qg(P{{A!{c2)h-@7pw)=jqqHE3vSgKJ&s2 zex0V)xGD?3^4KfkSAug=uX3K-y^#Bd)nJJ}G&=CL=swl+gI+D+sK_8$qDp)%XQ37D z39ES)E7(iwT<@KwOj+0Ui+AO$`pLVN`#X6E(ehNO=GR)c7%_|Nb3t+Jn-^TiifQY4 zJnB_h$~xhdE7niSm$F{s<7m_SzF(iK9w|kfGcdMP=nSHYkJZr#GPT_50!28(?igkiu_KItO6Uv?Rju z7^0z6DGqV4pI_a8fC-}-coEo!>I&LkrRvw?onESvQ9wRK8s&k-$Bcgqv8$zY-nd*k zQPpJo)RU+T@wtr<-Tp&jh!p|o#y3PloPW52SXKH8u+?A>Zn%1tK0nXapr(=1S(*34 zKqo8<;j47l{lH_0rgpy!aywmdgv}b@Zw-?bYf;->%l6>!arx?foL+iWSkPV*6(O`< zzIwIVV3XNAd)HZ5gKUJc@mbLkMFrc)=GPj$rCq6AXASBE^<2Phzq)|l)Gn6psYTtD zT9^&k-AEzbVi%=LM4JduWhqK6uXkH0UWheP0j+oE++w$P|9O^oEq~_*pkd(+H!{BI z)e+v1#`_(e_diR7`M^(IW*In_cyzKAw1~cAGgkz~*9(Iv1gD;Tqx#b^4{*+y>XvrX z`Zf-pDALfz&^EFPi4}jQS<&PcV}pz#Cs6K@kf#vsz-2A}lqzM!f0 zF;A(kESU$bUQfSR?gusXC=&B^8F8$|Qg$l}WNryC}FS^BihR7j z4QN7aW-297E#r|;*a(YR*`zS4vH9K=PK5qCK&*I{a)iXh9h!+py#cKCW6H~ysb5Uo z3ag|Hv(vmwul;P{CMABVytJh|B1xF#5gC>6|86P|MHjjciz`CkWBWBPkduI(K9?WlIR&6;w$qB zzMW`7b*Kr)heig5PY%}Oo*=B}@v#{s=2TEua&&x1UZ0F}^0L6(9Rs7oqhsSX<^m;% z^8VOxPgi2>VXnOsr)J=ks6b}Q9N3H9C_!lp5z{atNDhrm93J{66^tqjtq zfw)AcvxAbUgNk_{g1zz~l#*xFDr$PY8Np6Cs~e@JMc$^sKDK99Bb@NgfRr)TE8AdJ zAzX4Ajzg#3u zo4gkAg5lJ^Y~UjU7nKpygfw+~#*!M{Owpt~-1vc5y3NA+PD@OVtJ;@Mw{1?-8DJk5 z8F02F0rsp7{JtgYwHCvxd)^d_qj0v7H;UG~5WHaGSJERK?(xe!?+dnm34ulnT*g<3 zZR~jG-oJ)(`$emDH-gW@x#P4c>eduiisz7fRnmc=O99 zd)<1~kam0o=guwz9P;Osg)M3Y+GbR5<^4wpx4mbWuJFrnw)2XXausOf$^QavfzecA zPt}$Lc9vi`kb+0GY=98Gxd@70_R2pCih9j5ygg0kxjp})py-@~_qi%vfFh>~F9{ME ztn`^s^yF%$H?+Y*T%hO{9F&Qq;xxj62<+11?5P00jp&ro{JCKfA;99eeL=7wcpjeJRa}L6l{O@q`wPM~GNYFB-YUjh`w5b+1 z>2oI1NWmljg&O-Pwa;G2dON-6TAW;b-OY&B@e!viF3GJ%&Xf^%GW_65Gt%;U)~9DA zI7lLSw8|RmN-p`-bk~JY8@eb86}Mq^8!8UZ@;Y=L)y{;-x7Tw@2nlM(x?leRs;in9 zj4|nGcDmEviR!gflO~H1YnqCS?iD6tslAqP69c2tk9F}DPHpw5GzfHf9@W)Jm49(0 z--%VK-Xxqelc|D8nb2_l0PGYNyr_ zj3-5^i_?TQMGgGSjiX%SNP5?zqf67_muq3v>!pP2$)Yk?TK}AMr?h*r(d%nF#03G{ z6h_zx!0@x#^IkS9e)8!7??QBcMbjPk$~E0dPxtM7{ z)^b>Jh0BE1H`m_g%JpMSq+bVfPpP#$z?@~Cu7lWfo)^~63zb*9E*0X1i01{#dwtsD zU5MPAE1rjF;wFt7O z%9x{gUFQja3=JW%>(@0&oV^q&yDIHcVvkQpybEFJ)>wSkxnZpW<$$M+vz7`JyGG`b z`QaaG^oD=hS0|!gcl`>p_GYE4Q3#{B0}Y? zTmG1))$f)KV)^_WI4R~Y%r?CuCAEuFg(9)MN0Z@~FP8D9E2GRrQeuZkpT_^&8b2o# zMap}hsNP9>{@cU{GK^Q$@U%K4TQZdf^_SwXIO8IlrF>C6T}6L|vC?$6AJ`R2r0eEK zHD&(zSH`CN*-7*WNzk+6$ja{p@GWfI|HQWpf zNA5yN6g3f6ac*vS;;6mB8%2S5qXh}Yd~b-FB&3?vfL3_ zYUhr~e#|V3$Rf6wi0m6CQJfzlYbcV|^SSGW$ZN77@+}L9yw*cxU4OqjA|XSvU_@S< zFCq&n3+0D=#mj2*vr9+hOfyApi2S+d$hW#aSD(uw@~s?Ug(9+&QFKHWt%V};A{p0! z$iiPVL>6VaBeK-a9g+Q*Sr(B+Y%vkpH%y{AKSb70q_{cqtqX{J+kre0`7_@9=4aRcksO&X zlICeyM6TrsD>O$|GK!AKqP0*&UL@lh5Lx((hRC8UcSM%jxg)Y4Gs_~fh%F`}`-VwG z=ZDA|iWE0Tu3bRn8!t!p-!JEfeA?{xMbDA-ude60vzP5XGQT^K@)7xN?;`7Kpka25IB&23p zOLq2beD`zQ*i))<-q@4cxdXEN971T=J*oC)>g)y)n+cG!_H`i4Uo}#y?CbHn58PcZ z4WcC1eLdeUF-wn$<@fb83|W*RKc%&>pnbh8Z;>%5jkLU-y&Eq_F7eu*A0lhB+sz!A zL%_|#a{jKxI?w5HS~f>sNBM>3$Vx^gO#WQIYav<-&5;+$xP}~A_=}b!i?ZBvWT~Ay zB>OS5Y>q5qGeL5;t}gVu7QSH;%=uxmh9bqyk=NbGIdZ8ul9V4JYxCO|Jx4y``bQ-t z*C|I%*LgDKv@9amafB6$$Vx`h5m~eripYy(TmvEtf6)+Gl;w`dQag7<_G4yQL>95d zL}cGE3FiC|SwoRUS@P%pU5mN}M85HIWciY{P=1K4&2Beyu z7mCPAM$r*jv=)lUi)35_A`5@f5LuMvj>u9wcSQDMW?4iQvBgAW-!KX1{190~k>cja z(FH`l@!liz*8qz0Lu74syO|@;kNKsDob5ewy54iToR&r8dde>pk(G?1BeG~M6p|(!Qbf-Bo4uIpbM?6_BJ+PA6^zJAM$r*jv=)lUi)35_A`5@f5LuMvj>u9w zcSQDMW?4iQvBgAW-!O^h{190~k>cjau?0lF@p5GT)KXEzJ9F2Y|M$#bue#)a7ens! z|37etR>%JZqWVE`+W)P({HQQD4*x&FF6C&9c~lq0)U{%^-~=kR~TzLX=oRsQdO zmU29twH^G`qoUk7{Qq09l;dDl9sd7hSjw?CD~JDefu$VxW#w3zr5%T}a`>6RQXL&x zIsEr)OF8~BD~G>pEgX7$S7;o5d@q&yr&=99+F~*+(t#{(ZPxy?^I{HD Date: Wed, 19 Feb 2025 08:44:43 -0500 Subject: [PATCH 09/12] Add back admin path for run tests --- test/run-tests.ps1 | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/test/run-tests.ps1 b/test/run-tests.ps1 index 570d31b07e..8fea4a068e 100644 --- a/test/run-tests.ps1 +++ b/test/run-tests.ps1 @@ -1,13 +1,26 @@ -$env:VK_LAYER_PATH="$pwd" -$env:VK_IMPLICIT_LAYER_PATH="" -$env:VK_DRIVER_FILES="$pwd\test_apps\VkICD_mock_icd.json" -$env:VK_INSTANCE_LAYERS="VK_LAYER_LUNARG_gfxreconstruct" +$is_admin = ([Security.Principal.WindowsPrincipal] ` + [Security.Principal.WindowsIdentity]::GetCurrent() ` + ).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator); + +if ($is_admin) { + New-Item -Path "HKLM:\SOFTWARE\Khronos" + New-Item -Path "HKLM:\SOFTWARE\Khronos\Vulkan" + New-Item -Path "HKLM:\SOFTWARE\Khronos\Vulkan\ImplicitLayers" + New-ItemProperty -Path "HKLM:\SOFTWARE\Khronos\Vulkan\ImplicitLayers" -Name "$pwd\VkLayer_gfxreconstruct.json" -PropertyType "DWord" -Value 0 + New-Item -Path "HKLM:\SOFTWARE\Khronos\Vulkan\Drivers" + New-ItemProperty -Path "HKLM:\SOFTWARE\Khronos\Vulkan\Drivers" -Name "$pwd\test_apps\VkICD_mock_icd.json" -PropertyType "DWord" -Value 0 +} else { + $env:VK_LAYER_PATH="$pwd" + $env:VK_IMPLICIT_LAYER_PATH="" + $env:VK_DRIVER_FILES="$pwd\test_apps\VkICD_mock_icd.json" + $env:VK_INSTANCE_LAYERS="VK_LAYER_LUNARG_gfxreconstruct" +} $env:VK_LOADER_LAYERS_DISABLE="~all~" $env:VK_LOADER_LAYERS_ENABLE="*gfxreconstruct*" $env:GFXRECON_CAPTURE_FILE_TIMESTAMP="false" $env:GFXRECON_CAPTURE_FILE="actual.gfxr" $env:GFXRECON_TESTAPP_HEADLESS="true" $env:GFXRECON_TESTAPP_MOCK_ICD="$pwd\test_apps\VkICD_mock_icd.dll" -#$env:GFXRECON_LOG_LEVEL="info" -#$env:VK_LOADER_DEBUG="all" +$env:GFXRECON_LOG_LEVEL="" +$env:VK_LOADER_DEBUG="" ./gfxrecon-testapp-runner.exe \ No newline at end of file From 608d8297ab7e16db49994e6f6742f83531128940 Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Wed, 19 Feb 2025 10:09:31 -0500 Subject: [PATCH 10/12] Update macos known good gfxrs --- test/known_good/multisample-depth_macos.gfxr | Bin 28152 -> 28209 bytes test/known_good/pipeline-binaries_macos.gfxr | Bin 8836 -> 8879 bytes test/known_good/shader-objects_macos.gfxr | Bin 56335 -> 56372 bytes test/known_good/triangle_macos.gfxr | Bin 25844 -> 25869 bytes 4 files changed, 0 insertions(+), 0 deletions(-) diff --git a/test/known_good/multisample-depth_macos.gfxr b/test/known_good/multisample-depth_macos.gfxr index f2ef0002f27920151a9574ca3cfb7f3291659ad5..ff8e22cbac7f0fc25fec26fc79f174362740cfe6 100644 GIT binary patch delta 5629 zcmb`Kdu&tp701uL*GcTeNv`9>kJzz|sJ~Y z@W5BHfA`*Vey`8(dw%D4mp*3BTw?-0Df3fok}8=g?36ai-DR%24p(Kpv#P!dPfE+O z`UYzs>l^GZHZ>3Q9@vGSNG*pqFd$wM06*{yL>}RXk(=NmnJ51_wMTd+CmviwWz#(L zNzP4q3dud707xU-)X5DJJ4jhzDj}!55`YD$ghQ9f^tzxz-Z6-@cw;nP~LEZBFhOWdtqek!02F4-+&p+nY+#cuQmc}1~>~xh6Z~2_YRDW zl>*c-z2~XxrIJkyw~J|`TYzoizc@>OsX|17zI3%`sbqQ&5AEWF)o=x1*^Kodp?R7> zY%Sofgdjb}u4a5Sy;wb8F4SN5&KsUWHSv?e7NP49{yx2q^XjKDJEKlPCHWBGlNZR= z#w_6Wj8@sy)aPjecLv|i_%2g{b#jY3lp@sryLMV!5svPQ=(iKcs!PF%pQzM~7w@W!j0x516Rcwmewvv}uP&+!70MwWC|DhE zzk?iJ5Bd@OT)jBw7pOk8<9xP}_`? z4v<4FNE~3CagawhC^Idv`vbZS9z6*BNVhy!8imOEU~K)YU;>KHfUoJMPI zL#o}~55ZJq^6I%<>asC!Z4Q-@&=i#uqMnZBHFLS{h}r!G^JK()mKqdlQ@Omhfc{us z9@C2rsuFI7X17~qlk(@=AS8Ky0Z*tJxNf!s7gS!Rhvf1)Ig(oNeYKV8!`tdhTt8Xg z)6_Eq_z%rSE%0t>(89j@=$?)4cH`hjQ|E8^yg=E6aCw&X(%&*tK35)b} zQ5zjIpVn!(0ChN_^NPcGSLczyqi8EKr1c8bC!Dyc$i`MYf#XG8 zY;8IIp{S*4<|e3h#81P34|;v9um-%i3;RKtLy2Wbh_{<}(*D!)BF*TLQ?%W43DDTtuoiszQVrsxJ>qEPyZD>hEj6PWH*D z)Fbt!5Z25LyMR@8@2d6y*}rG^ievk=oiK(arbUmvdeus&sFJsM^+xB&j>TRBO<0US ziUbM>VMdgU!sEI~E`KTZu~aCU3YbQ$XsV>Zmq7?R@R}4zqgomhC{hi;dO-*1?=#?dMU60qk^V5C@~nJOcri>f9uIdVOb{!o zt+;7Rt%z->SHO1N8OQdND~fFlKXYY9(U}b-+@OH#2K`oLm?^m3NnIqL2a>$&UPt%barC` z0e!4-CAt^aCPRj%7|LYGaNhU-$*_4{9NxKgVR+Zq#dpHj*541@$LkXSx1)I_xb_VX zqq#LPP|48TTN@umb9_r2+eE=w15(z45-T2Jru;8BCoWFYNy|p=v z>1dlVl6n{0VuE{aS?VpmZ|a2(A(cv!mwc<+A6jx5bCyVI4_eSr>Yz_MQjK^*jh
    V&~4mhd3V=#Rw*2SG@Z4Lrav-hmBp) zU2$uSXKQzyr!_I2f?I+-JA0x$!>8N>Hq)$ delta 5389 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 E4^c13h5!Hn diff --git a/test/known_good/pipeline-binaries_macos.gfxr b/test/known_good/pipeline-binaries_macos.gfxr index 166e12b4269ef1e47859ac7ac507289a8783a6e7..0f5e66fd3e7db1d2bca3afe70df85f724c57b835 100644 GIT binary patch delta 1871 zcmZWqZA?>V6n^gI7F#Igwztx13oWI{$BMKCmMULWG!ey!iiQxSlyZ?9p>(t;Ml!nS zkHsvR+55}PID}={k7YJUmV%;G+h)h%ZJSmMrmDVxb|a(mDF zzUQ3xJm);;^z!~&`*TsF@EO}Lc1%{A*&GuO;|uxP}vX2tkh4;g6y++ApH_9=#)HxO)9T7ocykxI|bjK>qI56b&K$PN!gAJ+B{4#XzZ z_}HYHPQLd(Hymt!5Z>R8!#CY$>Wj`2yeHZ5cCCpX$_9FSpz zeAf(HkQqvLNqv>tG}~Jev2lSgNLX4Ulf_Dp$lfaHGhKHFB%U9EJuLauD!DX0TO4{V zy+iDS(gtO7*N&yfv>6r3!5)@22+>SO*gzdRR( zRdk`qD%fN<+*vkQc4GS|2jQ*>2!vOp>SVhqF?-$c_}Ld_N2Ngzp>|m!)>O?#aK)s~ zW6!WLOF*3Svv({9r6+`zJ+QP(kGZgFYnQno6kx9M6qPD{8>cJfQM-OhPPj9E|Ke1) z$SiUtQ8yqr)Eey@ciBNf`Bp1rMCWqvwv!x9)6b8yGL%7fQFbpJX%-5EiV_WB6eRkX zg{-c2CHW#A&+PJ6$vn*|-fiX~lD& zKXBx8SY;dXRL=rYr)DQJ3)(qNJ@1Fl*z1R^RAY-Dxww|hsL6OTp@!=a^7eH70PD6| z80zp;Ow6e9j2fF!lVj>kDxOX^L5Vg&b~mDU0QurEHIL z`|m(rbK)4MOy1rj`CG{TJ$skJg$+Z!?fN$r*7yZnfeSAw1i6B@qRWyaOnkqbnB#3> zXDb>^^4)#NOI+bbMZ5KC!Lw1126&zQQqfrXylKOXIvq3&!jOthkk_^#*m`N`cF3_) z+IpPNmwZPta$>e%3l~ef8ms(vu8KkYZ?%Qo>yvu z4jkuAFvj9lTYW93cpuPE=;4!g073_3)7F3KedV`hcCD&v!8aJ5heOG5P3a?QC!iim zupSP3J>;SW6p<5R`!}IJC>7M5bk8aNT_JYFk7-?do8a5#X zoX~e(FZP%{tv^)Ko<7WGHxYd9f(qB={s!6vn;*IIo0cR3lnVI S+xhZxjh0V{FSiZV3&KBlT9sx1 delta 1834 zcma)7Z%k8H6#w1VS1eHIZC`1tEw+?0{s^-mZeU?n4Vm-Lf)xx~R4DMA-Jl_~2sjK~ zwhtyVOPA}CEsMsXi(6tc6t*ex10g0OMi)LT8OySSF#KSaW!-lZcWzq}Kkg>?zH{&S z-E;5xopbK{uH&PQ*|3TIDE65&c2#tn_LVd?H0|nYY}pfR+0)o8uAAz4f76-%=&Mb& zzKA}gM-#gE!xWgFN3N+r3Y>xE=TGzB#dQ+;!Z(MdLWRGQ5X=SJITxS+E~FlkV)y$I zr3NMi78i_-;NfbdOK6=Ccr=6vy2%L7&fDN$n(6{CwIZWnKXBr3@8N@y-o)7GndpG- zhxV5rR;Lflj|Uw+UA<@Z=-`l^NbCTZ}ab-|bk;J9Sy zhPYt%vN3VR{Dt%Kxo1EVBX(YT{+x)v1_a=~A&!;=_(~X7#SMd%*|-OuRq;Vd_f{;! zpB%4e;7}CwrS?*=_Iu!+5}A@?>a6svqqN1kOa#a<6;R)x{z!aMTCc23i2J37)Jx=% zD6)jqTT*z#65>)|cFag9mo!|q9LZ@nEMa?An>Qwj>icaBqJ@{UAH)e>+yD7M?kqd) zg+F+Ph@Y7KGDLFb4h?^f(O{b6NZqZO302bmHc7cf!DILs-*|$^qHf6NL|CSYiK+B4 zvy?n68l9wPl`9mWr7L9koxfvOi zwE5&39ve!=&c*cc05n$sR?Uxs0A{1Hcv6o?;{$qAH5$XqW50uM4WQsK{#6D>^=Q(m z_m1lEL49;2nn*N2^EJTg*#V>Y*y`z{9OJGA6r4h0a55epjt!hfFcyD@ZaOiGQog$y zTDlrm$1xZ`L94Ey@(iYi1%b3e{K^0fs z4pHaSR1@XA*ynT@7E-NqZ#!RB?R@Dg7}^RjtE94E8n%fm?z(abl~yQKQ0YVy`jkR& z@;~@yrbRq)A1&&XuYh?76_^WolFZ1LqA-Z>%Udhcc>=cQ_A&)lV*z&2rZdbk(H!<= z>H=#6FD%0>P2>}DXdttQ!|c9Uy7PwX{I7shQ_Dh)ROXW^;VXy8mh<1 z8*tidzzwx95S~gvOVi+>(p3P$^)PMKBg(z5>E$3LO$BUh1X^bRPUnbx)X~YX6Qv4# zslBsQ1YtN`VVHt&8e4%uhGuBXzcA;v=B!0Clf`}?8hWHZRP!a8rC!l8Jy2Jfne0tL z8zJj%s@n}9jQ&M;_6H&6y$(ZgZcRM)Uax4$2mN0D0a0Nyd%=iZa-xRnSbXYh{~xG- PeC=u<*_sPhOtb$00lJr+ diff --git a/test/known_good/shader-objects_macos.gfxr b/test/known_good/shader-objects_macos.gfxr index 149c0a42ff278c39cd35e37a70cd3a608bf8b7e8..95825ec899b541ce7b6d612ff96bc765448d0776 100644 GIT binary patch literal 56372 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 literal 56335 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 C>q^!D literal 25844 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 Date: Wed, 19 Feb 2025 11:09:55 -0500 Subject: [PATCH 11/12] Update test app verification readme with Windows specific instructions --- TESTING_test_apps.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/TESTING_test_apps.md b/TESTING_test_apps.md index 5709e89000..02698b53d2 100644 --- a/TESTING_test_apps.md +++ b/TESTING_test_apps.md @@ -41,6 +41,8 @@ Test apps are built as part of the default build CMAKE build process. In order t To run the test apps and validate output against known good '.gfxr' files, build the project and then run the test script from within the 'test' install directory. +*On Windows:* The test app must not be run as administrator. If you receive an error that the ps1 script is not digitally signed, you will need to run 'Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine' to allow the script to run. + |Operating System| ./scripts/build.py Test Directory |Test Script| |---------------|------------------------------------|------------| From bb1adde9184726bb2e9278381a5c6d8a364f5b17 Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Wed, 19 Feb 2025 11:12:45 -0500 Subject: [PATCH 12/12] Remove powershell debug env vars --- test/run-tests.ps1 | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/run-tests.ps1 b/test/run-tests.ps1 index 8fea4a068e..dcd7109fa5 100644 --- a/test/run-tests.ps1 +++ b/test/run-tests.ps1 @@ -21,6 +21,6 @@ $env:GFXRECON_CAPTURE_FILE_TIMESTAMP="false" $env:GFXRECON_CAPTURE_FILE="actual.gfxr" $env:GFXRECON_TESTAPP_HEADLESS="true" $env:GFXRECON_TESTAPP_MOCK_ICD="$pwd\test_apps\VkICD_mock_icd.dll" -$env:GFXRECON_LOG_LEVEL="" -$env:VK_LOADER_DEBUG="" +#$env:GFXRECON_LOG_LEVEL="" +#$env:VK_LOADER_DEBUG="" ./gfxrecon-testapp-runner.exe \ No newline at end of file